helixmind 0.5.4

package/dist/cli/validation/static-checks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Static validation checks — no LLM calls, pure algorithms.
+ * Fast (~50ms) pattern matching, parsing, and analysis.
+ */
+export interface CheckResult {
+    id: string;
+    passed: boolean;
+    details: string;
+    fix?: string;
+    severity: 'error' | 'warning' | 'info';
+    autofix: boolean;
+}
+export interface StaticCheckContext {
+    lang?: string;
+    projectFiles?: string[];
+}
+/**
+ * Run all applicable static checks on the output.
+ */
+export declare function runStaticChecks(output: string, criterionIds: string[], context?: StaticCheckContext): CheckResult[];
+/**
+ * Extract code from markdown code blocks with given language hints.
+ * Also handles raw code without blocks.
+ */
+export declare function extractCodeContent(output: string, languages: string[]): string | null;
+//# sourceMappingURL=static-checks.d.ts.map

package/dist/cli/validation/static-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-checks.d.ts","sourceRoot":"","sources":["../../../src/cli/validation/static-checks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AA2dD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,EAAE,CAgBf;AAYD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAyBrF"}

package/dist/cli/validation/static-checks.js

@@ -0,0 +1,648 @@
+/**
+ * Static validation checks — no LLM calls, pure algorithms.
+ * Fast (~50ms) pattern matching, parsing, and analysis.
+ */
+// ── Void HTML elements (self-closing) ──
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+// ── Static Checkers ──
+const checkers = {
+    'html-valid': (output) => {
+        // Extract code blocks that contain HTML
+        const html = extractCodeContent(output, ['html', 'jsx', 'tsx', 'vue', 'svelte']);
+        if (!html)
+            return pass('html-valid', 'No HTML content found');
+        const stack = [];
+        const tagRegex = /<\/?([a-zA-Z][a-zA-Z0-9-]*)[^>]*\/?>/g;
+        let match;
+        while ((match = tagRegex.exec(html)) !== null) {
+            const fullTag = match[0];
+            const tagName = match[1].toLowerCase();
+            if (VOID_ELEMENTS.has(tagName))
+                continue;
+            if (fullTag.endsWith('/>'))
+                continue; // Self-closing
+            if (fullTag.startsWith('</')) {
+                // Closing tag
+                if (stack.length === 0) {
+                    return fail('html-valid', `Unexpected closing tag </${tagName}>`, `Remove stray </${tagName}>`);
+                }
+                const expected = stack.pop();
+                if (expected !== tagName) {
+                    return fail('html-valid', `Mismatched tags: expected </${expected}>, found </${tagName}>`, `Change </${tagName}> to </${expected}>`);
+                }
+            }
+            else {
+                // Opening tag
+                stack.push(tagName);
+            }
+        }
+        if (stack.length > 0) {
+            const unclosed = stack.reverse().map(t => `<${t}>`).join(', ');
+            return fail('html-valid', `Unclosed tags: ${unclosed}`, stack.map(t => `</${t}>`).join('\n'));
+        }
+        return pass('html-valid', 'HTML tags properly balanced');
+    },
+    'links-valid': (output) => {
+        const html = extractCodeContent(output, ['html', 'jsx', 'tsx', 'vue']);
+        if (!html)
+            return pass('links-valid', 'No HTML content found');
+        const hrefRegex = /(?:href|src|action)=["']([^"']*?)["']/gi;
+        const issues = [];
+        let match;
+        while ((match = hrefRegex.exec(html)) !== null) {
+            const value = match[1];
+            if (!value || value === '' || value === '#undefined' || value === 'undefined') {
+                issues.push(`Empty/invalid ${match[0]}`);
+            }
+        }
+        if (issues.length > 0) {
+            return fail('links-valid', issues.join('; '), undefined, 'error');
+        }
+        return pass('links-valid', 'All links valid');
+    },
+    'ids-unique': (output) => {
+        const html = extractCodeContent(output, ['html', 'jsx', 'tsx', 'vue']);
+        if (!html)
+            return pass('ids-unique', 'No HTML content found');
+        const idRegex = /\bid=["']([^"']+)["']/gi;
+        const seen = new Map();
+        let match;
+        while ((match = idRegex.exec(html)) !== null) {
+            const id = match[1];
+            seen.set(id, (seen.get(id) || 0) + 1);
+        }
+        const duplicates = [...seen.entries()].filter(([, count]) => count > 1);
+        if (duplicates.length > 0) {
+            const dupeList = duplicates.map(([id, count]) => `"${id}" (${count}x)`).join(', ');
+            return fail('ids-unique', `Duplicate IDs: ${dupeList}`, `Rename duplicate IDs to be unique`);
+        }
+        return pass('ids-unique', 'All IDs unique');
+    },
+    'img-alt': (output) => {
+        const html = extractCodeContent(output, ['html', 'jsx', 'tsx', 'vue']);
+        if (!html)
+            return pass('img-alt', 'No HTML content found');
+        const imgRegex = /<img\b[^>]*>/gi;
+        const images = html.match(imgRegex) || [];
+        const missingAlt = images.filter(img => !img.includes('alt='));
+        if (missingAlt.length > 0) {
+            return {
+                id: 'img-alt',
+                passed: false,
+                details: `${missingAlt.length} image(s) missing alt attribute`,
+                fix: 'Add alt="" to images',
+                severity: 'warning',
+                autofix: true,
+            };
+        }
+        return pass('img-alt', 'All images have alt attributes', 'warning');
+    },
+    'syntax-valid': (output, ctx) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript', 'json', 'css']);
+        if (!code)
+            return pass('syntax-valid', 'No code content found');
+        const lang = ctx?.lang || detectLanguage(code);
+        if (lang === 'json') {
+            try {
+                JSON.parse(code);
+                return pass('syntax-valid', 'Valid JSON');
+            }
+            catch (e) {
+                return fail('syntax-valid', `Invalid JSON: ${e.message}`);
+            }
+        }
+        // Check bracket/brace/paren balance
+        const balance = checkBracketBalance(code);
+        if (!balance.balanced) {
+            return fail('syntax-valid', `Unbalanced ${balance.type}: ${balance.details}`, balance.fix);
+        }
+        // Check for obvious syntax errors
+        const syntaxIssues = checkBasicSyntax(code);
+        if (syntaxIssues) {
+            return fail('syntax-valid', syntaxIssues);
+        }
+        return pass('syntax-valid', 'Syntax appears valid');
+    },
+    'imports-resolve': (output, ctx) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('imports-resolve', 'No code content found');
+        const importRegex = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
+        const issues = [];
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            const path = match[1];
+            // Skip node_modules imports
+            if (!path.startsWith('.') && !path.startsWith('/'))
+                continue;
+            if (ctx?.projectFiles && ctx.projectFiles.length > 0) {
+                // Check if file exists in known project files
+                const normalized = path.replace(/\.(js|ts|jsx|tsx)$/, '');
+                const found = ctx.projectFiles.some(f => f.includes(normalized) || f.includes(normalized + '.ts') || f.includes(normalized + '.js'));
+                if (!found) {
+                    issues.push(`Import "${path}" may not exist`);
+                }
+            }
+        }
+        if (issues.length > 0) {
+            return fail('imports-resolve', issues.join('; '));
+        }
+        return pass('imports-resolve', 'All imports appear valid');
+    },
+    'no-dead-code': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('no-dead-code', 'No code content found');
+        const issues = [];
+        // Check for unreachable code after return/throw/break/continue
+        const unreachableRegex = /\b(return|throw|break|continue)\b[^;]*;\s*\n\s*(?![\s}]|\/\/|\/\*|case\s|default:)([\w])/gm;
+        if (unreachableRegex.test(code)) {
+            issues.push('Possible unreachable code after return/throw');
+        }
+        // Check for unused imports (simple heuristic)
+        const importNames = extractImportNames(code);
+        for (const name of importNames) {
+            // Count occurrences after the import line
+            const afterImport = code.slice(code.indexOf(name) + name.length);
+            if (!afterImport.includes(name)) {
+                issues.push(`Possibly unused import: ${name}`);
+            }
+        }
+        if (issues.length > 0) {
+            return { id: 'no-dead-code', passed: false, details: issues.join('; '), severity: 'warning', autofix: true };
+        }
+        return pass('no-dead-code', 'No dead code detected', 'warning');
+    },
+    'no-hardcoded': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript', 'py', 'python']);
+        if (!code)
+            return pass('no-hardcoded', 'No code content found');
+        const issues = [];
+        // API keys / secrets patterns
+        const secretPatterns = [
+            /['"][A-Za-z0-9+/]{40,}['"]/, // Long base64-like strings
+            /(?:api[_-]?key|secret|password|token)\s*[:=]\s*['"][^'"]{8,}['"]/i,
+            /sk-[a-zA-Z0-9]{20,}/, // OpenAI key pattern
+            /ghp_[a-zA-Z0-9]{36}/, // GitHub PAT
+            /(?:AKIA|ASIA)[A-Z0-9]{16}/, // AWS access key
+        ];
+        for (const pattern of secretPatterns) {
+            if (pattern.test(code)) {
+                issues.push('Possible hardcoded secret/API key detected');
+                break;
+            }
+        }
+        // Hardcoded localhost URLs (not in comments/config)
+        if (/['"]https?:\/\/localhost:\d+/.test(code) && !code.includes('// dev') && !code.includes('development')) {
+            issues.push('Hardcoded localhost URL');
+        }
+        if (issues.length > 0) {
+            return { id: 'no-hardcoded', passed: false, details: issues.join('; '), severity: 'warning', autofix: false };
+        }
+        return pass('no-hardcoded', 'No hardcoded secrets detected', 'warning');
+    },
+    'sql-injection': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript', 'py', 'python']);
+        if (!code)
+            return pass('sql-injection', 'No code content found');
+        // Check for string concatenation in SQL queries
+        const sqlConcat = /(?:query|exec|execute|run|prepare)\s*\(\s*[`'"](?:SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER)\b[^`'"]*\$\{/i;
+        const sqlPlus = /(?:query|exec|execute|run)\s*\(\s*['"](?:SELECT|INSERT|UPDATE|DELETE)\b[^'"]*['"]\s*\+/i;
+        if (sqlConcat.test(code) || sqlPlus.test(code)) {
+            return fail('sql-injection', 'SQL query with string interpolation/concatenation detected', 'Use parameterized queries instead');
+        }
+        return pass('sql-injection', 'No SQL injection vulnerabilities detected');
+    },
+    'async-await': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('async-await', 'No async code found');
+        const issues = [];
+        // Find async function declarations and check if they use await.
+        // Use bracket counting instead of regex to handle nested blocks correctly.
+        const asyncPattern = /async\s+(?:function\s+)?(\w+)\s*\([^)]*\)\s*\{/g;
+        let match;
+        while ((match = asyncPattern.exec(code)) !== null) {
+            const funcName = match[1];
+            const bodyStart = match.index + match[0].length - 1; // index of opening {
+            const body = extractBalancedBlock(code, bodyStart);
+            if (body && !body.includes('await') && !body.includes('Promise') && !body.includes('.then(')) {
+                issues.push(`Async function "${funcName}" has no await`);
+            }
+        }
+        if (issues.length > 0) {
+            return fail('async-await', issues.join('; '));
+        }
+        return pass('async-await', 'Async/await usage appears correct');
+    },
+    'error-handling': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('error-handling', 'No code content found');
+        // Check if there are async operations without try/catch
+        const hasAsync = code.includes('await ');
+        const hasTryCatch = code.includes('try {') || code.includes('try{');
+        const hasCatch = code.includes('.catch(');
+        if (hasAsync && !hasTryCatch && !hasCatch) {
+            return fail('error-handling', 'Async operations without error handling', 'Wrap in try/catch');
+        }
+        return pass('error-handling', 'Error handling present');
+    },
+    'status-codes': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('status-codes', 'No HTTP status code usage found');
+        // Count status codes used
+        const statusRegex = /\.status\((\d{3})\)/g;
+        const codes = new Set();
+        let match;
+        while ((match = statusRegex.exec(code)) !== null) {
+            codes.add(match[1]);
+        }
+        if (codes.size > 0 && codes.size === 1 && codes.has('200')) {
+            return { id: 'status-codes', passed: false, details: 'Only status 200 used — use appropriate codes (201, 400, 404, 500)', severity: 'warning', autofix: true };
+        }
+        return pass('status-codes', 'HTTP status codes look appropriate', 'warning');
+    },
+    'assertions-exist': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('assertions-exist', 'No test code found');
+        // Find test blocks
+        const testRegex = /(?:it|test)\s*\(\s*['"][^'"]+['"]\s*,\s*(?:async\s*)?\(\s*\)\s*=>\s*\{([^]*?)(?=\n\s*(?:it|test|describe)\s*\(|\n\}\);\s*$)/g;
+        const issues = [];
+        let match;
+        while ((match = testRegex.exec(code)) !== null) {
+            const body = match[1];
+            if (!body.includes('expect(') && !body.includes('assert') && !body.includes('should')) {
+                // Extract test name for reporting
+                const nameMatch = code.slice(match.index).match(/['"]([^'"]+)['"]/);
+                issues.push(`Test "${nameMatch?.[1] || 'unknown'}" has no assertion`);
+            }
+        }
+        if (issues.length > 0) {
+            return fail('assertions-exist', issues.join('; '));
+        }
+        return pass('assertions-exist', 'All tests have assertions');
+    },
+    'mocks-cleanup': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('mocks-cleanup', 'No test code found');
+        const hasMocks = code.includes('vi.mock') || code.includes('jest.mock') || code.includes('sinon');
+        const hasCleanup = code.includes('afterEach') || code.includes('afterAll') || code.includes('restoreAllMocks') || code.includes('resetAllMocks') || code.includes('clearAllMocks');
+        if (hasMocks && !hasCleanup) {
+            return { id: 'mocks-cleanup', passed: false, details: 'Mocks used without cleanup (afterEach/restoreAllMocks)', fix: 'Add afterEach(() => vi.restoreAllMocks())', severity: 'warning', autofix: true };
+        }
+        return pass('mocks-cleanup', 'Mocks properly cleaned up', 'warning');
+    },
+    'input-handled': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript', 'py', 'python']);
+        if (!code)
+            return pass('input-handled', 'No code content found');
+        // Check for array/object operations without null checks
+        const hasArrayOps = /\.\s*(?:map|filter|reduce|forEach|find)\s*\(/.test(code);
+        const hasNullCheck = /(?:if\s*\(\s*!?\s*\w+|[\w.]+\s*\?\.|[\w.]+\s*!==?\s*(?:null|undefined))/.test(code);
+        if (hasArrayOps && !hasNullCheck) {
+            return fail('input-handled', 'Array operations without null/undefined checks', 'Add input validation');
+        }
+        return pass('input-handled', 'Input handling appears adequate');
+    },
+    'no-circular': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('no-circular', 'No code content found');
+        // Simple heuristic: check if a file imports itself or has obvious circular patterns
+        const importRegex = /import\s+.*from\s+['"]([^'"]+)['"]/g;
+        const exportRegex = /export\s+.*from\s+['"]([^'"]+)['"]/g;
+        const imports = new Set();
+        let match;
+        while ((match = importRegex.exec(code)) !== null)
+            imports.add(match[1]);
+        while ((match = exportRegex.exec(code)) !== null)
+            imports.add(match[1]);
+        // Can't detect circular deps from a single output — pass
+        return pass('no-circular', 'No obvious circular dependencies');
+    },
+    'no-secrets': (output) => {
+        const code = extractCodeContent(output, ['json', 'yaml', 'yml', 'toml', 'env', 'ini', 'cfg', 'ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('no-secrets', 'No config content found');
+        const secretKeys = /["']?(?:password|secret|api[_-]?key|token|private[_-]?key)["']?\s*[:=]\s*["']?[^\s"',}{]{5,}/i;
+        if (secretKeys.test(code)) {
+            return fail('no-secrets', 'Possible plaintext secret in configuration');
+        }
+        return pass('no-secrets', 'No plaintext secrets detected');
+    },
+    'code-duplication': (output) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript', 'py', 'python']);
+        if (!code)
+            return pass('code-duplication', 'No code content found');
+        // Extract meaningful lines — skip short lines, comments, and common boilerplate
+        const boilerplate = new Set(['return;', 'break;', 'continue;', 'default:', 'else {', '} else {', '});', '],', '});']);
+        const lines = code.split('\n')
+            .map(l => l.trim())
+            .filter(l => l.length > 40
+            && !l.startsWith('//')
+            && !l.startsWith('#')
+            && !l.startsWith('*')
+            && !l.startsWith('import ')
+            && !l.startsWith('return ')
+            && !boilerplate.has(l));
+        const lineCounts = new Map();
+        for (const line of lines) {
+            lineCounts.set(line, (lineCounts.get(line) || 0) + 1);
+        }
+        const duplicates = [...lineCounts.entries()].filter(([, count]) => count > 1);
+        if (duplicates.length > 3) {
+            const dupeList = duplicates.slice(0, 5).map(([line, count]) => `"${line.slice(0, 40)}..." (${count}x)`).join('; ');
+            return {
+                id: 'code-duplication',
+                passed: false,
+                details: `${duplicates.length} duplicate lines found: ${dupeList}`,
+                severity: 'warning',
+                autofix: false
+            };
+        }
+        return pass('code-duplication', 'No significant code duplication', 'warning');
+    },
+    'outdated-references': (output, ctx) => {
+        const code = extractCodeContent(output, ['ts', 'typescript', 'js', 'javascript']);
+        if (!code)
+            return pass('outdated-references', 'No code content found');
+        const issues = [];
+        const importRegex = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            const importPath = match[1];
+            // Skip node_modules imports
+            if (!importPath.startsWith('.') && !importPath.startsWith('/'))
+                continue;
+            // In ESM TypeScript, .js imports are the CORRECT pattern (compiled output).
+            // Flag .ts imports instead — they should use .js extension for ESM.
+            if (importPath.endsWith('.ts')) {
+                issues.push(`Import "${importPath}" uses .ts extension — ESM requires .js extension`);
+            }
+            // Check if file exists in project
+            if (ctx?.projectFiles && ctx.projectFiles.length > 0) {
+                const normalized = importPath.replace(/\.(js|ts|jsx|tsx)$/, '');
+                const found = ctx.projectFiles.some(f => f.includes(normalized) ||
+                    f.includes(normalized + '.ts') ||
+                    f.includes(normalized + '.js') ||
+                    f.includes(normalized + '/index.ts') ||
+                    f.includes(normalized + '/index.js'));
+                if (!found) {
+                    issues.push(`Import "${importPath}" may reference deleted/moved file`);
+                }
+            }
+        }
+        if (issues.length > 0) {
+            return {
+                id: 'outdated-references',
+                passed: false,
+                details: issues.slice(0, 5).join('; '),
+                severity: 'warning',
+                autofix: false
+            };
+        }
+        return pass('outdated-references', 'No outdated references detected', 'warning');
+    },
+};
+/**
+ * Run all applicable static checks on the output.
+ */
+export function runStaticChecks(output, criterionIds, context) {
+    const results = [];
+    for (const id of criterionIds) {
+        const checker = checkers[id];
+        if (checker) {
+            try {
+                results.push(checker(output, context));
+            }
+            catch {
+                // If a checker throws, mark as passed to avoid false negatives
+                results.push(pass(id, 'Check skipped (internal error)'));
+            }
+        }
+    }
+    return results;
+}
+// ── Helpers ──
+function pass(id, details, severity = 'error') {
+    return { id, passed: true, details, severity, autofix: false };
+}
+function fail(id, details, fix, severity = 'error') {
+    return { id, passed: false, details, fix, severity, autofix: !!fix };
+}
+/**
+ * Extract code from markdown code blocks with given language hints.
+ * Also handles raw code without blocks.
+ */
+export function extractCodeContent(output, languages) {
+    // Try to find fenced code blocks with matching language tags
+    const langPattern = languages.join('|');
+    // Match code blocks WITH the specified language, or code blocks with no language tag
+    const fencedRegex = new RegExp('```(?:(' + langPattern + ')\\s*\\n|\\s*\\n)([\\s\\S]*?)```', 'gi');
+    const blocks = [];
+    let match;
+    while ((match = fencedRegex.exec(output)) !== null) {
+        // match[1] = language tag (when lang matched), match[2] = code content
+        blocks.push(match[2]);
+    }
+    if (blocks.length > 0) {
+        return blocks.join('\n\n');
+    }
+    // No code blocks — check if the output itself looks like code
+    if (output.includes('function ') || output.includes('import ') ||
+        output.includes('class ') || output.includes('const ') ||
+        output.includes('<div') || output.includes('<html')) {
+        return output;
+    }
+    return null;
+}
+function detectLanguage(code) {
+    if (code.trim().startsWith('{') || code.trim().startsWith('['))
+        return 'json';
+    if (code.includes('import ') || code.includes('export '))
+        return 'typescript';
+    if (code.includes('<html') || code.includes('<div'))
+        return 'html';
+    if ((code.includes('def ') && !code.includes('default')) || (code.includes('class ') && code.includes(':')))
+        return 'python';
+    return 'typescript';
+}
+/**
+ * Extract the balanced block starting at the given index (which should point to '{').
+ * Returns the content between the braces, or null if unbalanced.
+ */
+function extractBalancedBlock(code, startIdx) {
+    if (code[startIdx] !== '{')
+        return null;
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    let escaped = false;
+    for (let i = startIdx; i < code.length; i++) {
+        const ch = code[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (inString) {
+            if (ch === stringChar && stringChar !== '`') {
+                inString = false;
+            }
+            else if (ch === stringChar && stringChar === '`') {
+                inString = false;
+            }
+            else if (stringChar === '`' && ch === '$' && code[i + 1] === '{') {
+                // Template literal expression — skip ${, count inner braces
+                i++; // skip $
+                // The { will be handled by the depth counter below
+            }
+            if (inString)
+                continue;
+        }
+        if (!inString && (ch === '"' || ch === "'" || ch === '`')) {
+            inString = true;
+            stringChar = ch;
+            continue;
+        }
+        if (ch === '/' && code[i + 1] === '/') {
+            const nl = code.indexOf('\n', i);
+            i = nl === -1 ? code.length : nl;
+            continue;
+        }
+        if (ch === '/' && code[i + 1] === '*') {
+            const end = code.indexOf('*/', i + 2);
+            i = end === -1 ? code.length : end + 1;
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return code.slice(startIdx + 1, i);
+        }
+    }
+    return null;
+}
+function checkBracketBalance(code) {
+    const pairs = { '(': ')', '[': ']', '{': '}' };
+    const stack = [];
+    let inString = false;
+    let stringChar = '';
+    let escaped = false;
+    let templateDepth = 0; // Track nested ${...} inside template literals
+    for (let i = 0; i < code.length; i++) {
+        const ch = code[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (inString) {
+            if (stringChar === '`') {
+                // Template literal: handle ${...} expressions
+                if (ch === '$' && code[i + 1] === '{') {
+                    templateDepth++;
+                    inString = false; // Exit string mode to count brackets in expression
+                    i++; // skip '{'
+                    stack.push('{');
+                    continue;
+                }
+                if (ch === '`') {
+                    inString = false;
+                }
+            }
+            else {
+                if (ch === stringChar)
+                    inString = false;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            inString = true;
+            stringChar = ch;
+            continue;
+        }
+        // Skip single-line comments
+        if (ch === '/' && code[i + 1] === '/') {
+            const nl = code.indexOf('\n', i);
+            i = nl === -1 ? code.length : nl;
+            continue;
+        }
+        // Skip multi-line comments
+        if (ch === '/' && code[i + 1] === '*') {
+            const end = code.indexOf('*/', i + 2);
+            i = end === -1 ? code.length : end + 1;
+            continue;
+        }
+        if (ch in pairs) {
+            stack.push(ch);
+        }
+        else if (ch === ')' || ch === ']' || ch === '}') {
+            const expected = stack.pop();
+            if (!expected) {
+                return { balanced: false, type: ch, details: `Unexpected '${ch}'`, fix: `Remove stray '${ch}'` };
+            }
+            if (pairs[expected] !== ch) {
+                return { balanced: false, type: ch, details: `Expected '${pairs[expected]}' but found '${ch}'`, fix: `Change '${ch}' to '${pairs[expected]}'` };
+            }
+            // If closing a template expression, re-enter template string mode
+            if (ch === '}' && templateDepth > 0 && expected === '{') {
+                templateDepth--;
+                inString = true;
+                stringChar = '`';
+            }
+        }
+    }
+    if (stack.length > 0) {
+        const unclosed = stack.map(s => pairs[s]).reverse().join('');
+        return { balanced: false, type: 'bracket', details: `Unclosed: ${stack.join(', ')}`, fix: `Add ${unclosed}` };
+    }
+    return { balanced: true };
+}
+function checkBasicSyntax(code) {
+    // Check for duplicate commas
+    if (/,,/.test(code))
+        return 'Duplicate commas found';
+    // Check for missing semicolons in obvious places (very conservative)
+    // Only flag if there's a clear pattern break
+    if (/\)\s*\n\s*(?:const|let|var|function|class|if|for|while)\b/.test(code)) {
+        // This is often valid (e.g., function call then statement), so don't flag
+    }
+    return null;
+}
+function extractImportNames(code) {
+    const names = [];
+    const regex = /import\s+(?:\{([^}]+)\}|(\w+))/g;
+    let match;
+    while ((match = regex.exec(code)) !== null) {
+        if (match[1]) {
+            // Named imports: { foo, bar as baz }
+            for (const part of match[1].split(',')) {
+                const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+                if (name && name.length > 1)
+                    names.push(name);
+            }
+        }
+        else if (match[2]) {
+            // Default import
+            names.push(match[2]);
+        }
+    }
+    return names;
+}
+//# sourceMappingURL=static-checks.js.map