Skip to content
BranchesTags

Repository files navigation

DesignFix- Extension

Official VS Code extension for DesignFix

About

DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.

Current Functionalities and Capabilities

1) Real-Time Workspace Sync

  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection

2) Continuous Java File Tracking

  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing

3) Rule and Tag Management

  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations

4) AI Fix Review and Safe Apply/Revert Workflow

  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:
    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content

5) Snippet Workflows

  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines

6) Design Rule Mining Pipeline

  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services

7) Code-to-XML Service Support

  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching

VS Code Commands

  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command

Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.

Requirements

  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)

Run in Development

  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.

Install Packaged VSIX

  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.

Developer Scripts

  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner

Maintainer Note

This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.

About

DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.

Resources

Readme
Activity

Stars

1 star

Watchers

1 watching

Forks

1 fork
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - yaad96/DesignFix--Extension: DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows. · GitHub
Skip to content
BranchesTags
Repository files navigation
DesignFix- Extension
Official VS Code extension for DesignFix
About
DesignFix- Extension is a Java-focused development companion that keeps design constraints actionable inside VS Code. It streams project context in real time, coordinates rule verification, and provides AI-assisted fix review workflows with one-click apply or revert.
Current Functionalities and Capabilities
1) Real-Time Workspace Sync
  • Starts a WebSocket server on port 8887 when the extension activates
  • Sends workspace project path and Java-focused project hierarchy to connected client services
  • Converts Java files to XML and streams initial XML snapshots on connection
2) Continuous Java File Tracking
  • Watches Java file create, delete, rename, and edit events
  • Re-converts changed Java files to XML and sends update messages automatically
  • Triggers per-file rule checks after XML updates
  • Sends focused Java file updates when active editor changes
  • Uses a debounce strategy (3 seconds) to reduce noisy update traffic during typing
3) Rule and Tag Management
  • Loads ruleTable.json and tagTable.json from workspace root
  • Creates missing rule/tag table files automatically
  • Supports new rule and new tag creation
  • Supports existing rule and tag updates
  • Returns success/failure acknowledgements over WebSocket for rule/tag operations
4) AI Fix Review and Safe Apply/Revert Workflow
  • Receives full-file AI modifications and opens side-by-side comparison views
  • Highlights added/removed diff regions in the editors
  • Shows AI explanation in VS Code status bar
  • Provides inline CodeLens actions:

    • Accept Change: writes reviewed content to target file
    • Reject Change: restores full original file content
5) Snippet Workflows
  • Opens generated Java snippets in a split editor with explanation comments
  • Locates and highlights converted Java snippet locations in target files
  • Supports request/response flow to fetch file content for edit-fix pipelines
6) Design Rule Mining Pipeline
  • Command-triggered mining entry point from editor context (Mine Rules)
  • Sends selected element metadata (path, offsets, line, token) for mining
  • Captures and sends DOI signals (recent files and caret activity)
  • Receives mining datasets/features/helper files (including append mode for large payloads)
  • Runs SPMF-based mining algorithms and sends mined results back to connected client services
7) Code-to-XML Service Support
  • Converts incoming code snippets/expressions to XML on demand
  • Returns XML responses with correlation message IDs for client-side matching
VS Code Commands
  • designfix.mineRules: requests design rule mining for selected element
  • designfix.acceptChange: applies AI-reviewed diff content to file
  • designfix.rejectChange: reverts to original file content
  • designfix.helloWorld: basic extension command
Note: command IDs currently use the designfix.* namespace for protocol and backward compatibility.
Requirements
  • VS Code ^1.86.0
  • Node.js and npm (for development builds)
  • srcml installed
  • Java runtime installed (required for mining execution)
  • spmf.jar available in workspace root (required for design rule mining runs)
  • A compatible DesignFix client/service connected over WebSocket (ws://localhost:8887)
Run in Development
  1. Open this folder in VS Code.
  2. Run npm install.
  3. Run npm run compile (or npm run watch).
  4. Press F5 to launch the extension host.
Install Packaged VSIX
  1. Open VS Code.
  2. Go to Extensions (Ctrl+Shift+X).
  3. Select ... -> Install from VSIX....
  4. Choose the .vsix package file and install.
Developer Scripts
  • npm run compile: TypeScript build
  • npm run watch: TypeScript watch mode
  • npm run lint: ESLint checks
  • npm run test: extension test runner
Maintainer Note
This extension is actively developed by Mainul Hossain as part of the DesignFix toolchain.
About
DesignFix is a VS Code extension that brings real-time design-rule intelligence directly into the editor. It links your workspace with the Active Documentation client to verify architecture rules continuously, synchronize project context live, and help developers review AI-generated fixes with clear explanations and fast accept/reject workflows.
Resources
Readme
Activity
Stars
1 star
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages