@chemx/starter-kit 26.9.28-276 → 26.10.4-235

package/cli/audit/rules.js

@@ -111,7 +111,7 @@ export const auditCode = (content, filePath, relativePath, options = {}) => {
 
   const lang = getLanguageForFile(filePath);
   if (lang?.id === 'csharp') {
-    analyzeCSharpCode(content, relativePath, violations);
+    analyzeCSharpCode(content, relativePath, violations, config);
   }
 
   if (options.fast || !isBabelParsable(filePath)) {

package/cli/audit.js

@@ -84,12 +84,12 @@ const IGNORED_DIRS = new Set([
   'out'
 ]);
 
-const isSourceFile = (name) => {
-  return isPolyglotSourceFile(name, { includeTests: false });
+const isSourceFile = (name, options = {}) => {
+  return isPolyglotSourceFile(name, { includeTests: false, ...options });
 };
 
 export const auditFile = (filePath, relativePath) => {
-  if (!isSourceFile(path.basename(filePath))) return [];
+  if (!isSourceFile(path.basename(filePath), { includeTests: true })) return [];
   const content = fs.readFileSync(filePath, 'utf-8');
   return auditCode(content, filePath, relativePath);
 };
@@ -125,12 +125,18 @@ export const scanTree = (targetDir, baseDir, scanOptions = {}) => {
   let fileStats = [];
   let totalHooks = 0;
 
+  const targetRel = path.relative(baseDir, targetDir);
+  const isTargetingTests = /(?:^|[\\/])(?:tests?|specs?)(?:[\\/]|$)/i.test(targetRel) ||
+    /(?:^|[\\/])(?:tests?|specs?)(?:[\\/]|$)/i.test(targetDir);
+  const includeTests = Boolean(scanOptions.includeTests || isTargetingTests);
+  const effectiveScanOptions = { ...scanOptions, includeTests };
+
   if (scanOptions.fileList && scanOptions.fileList.length > 0) {
     for (const item of scanOptions.fileList) {
       const fullPath = path.isAbsolute(item) ? item : path.resolve(baseDir, item);
       const relPath = path.relative(baseDir, fullPath);
-      if (fs.existsSync(fullPath) && isSourceFile(path.basename(fullPath))) {
-        const result = auditFileEntry(fullPath, relPath, scanOptions);
+      if (fs.existsSync(fullPath) && isSourceFile(path.basename(fullPath), { includeTests: true })) {
+        const result = auditFileEntry(fullPath, relPath, effectiveScanOptions);
         violations = violations.concat(result.fileViolations);
         fileStats.push(result.fileStat);
         totalHooks += result.hookCount;
@@ -150,13 +156,13 @@ export const scanTree = (targetDir, baseDir, scanOptions = {}) => {
 
     if (entry.isDirectory()) {
       if (!IGNORED_DIRS.has(entry.name)) {
-        const sub = scanTree(fullPath, baseDir, scanOptions);
+        const sub = scanTree(fullPath, baseDir, effectiveScanOptions);
         violations = violations.concat(sub.violations);
         fileStats = fileStats.concat(sub.fileStats);
         totalHooks += sub.totalHooks;
       }
-    } else if (isSourceFile(entry.name)) {
-      const result = auditFileEntry(fullPath, relPath, scanOptions);
+    } else if (isSourceFile(entry.name, { includeTests })) {
+      const result = auditFileEntry(fullPath, relPath, effectiveScanOptions);
       violations = violations.concat(result.fileViolations);
       fileStats.push(result.fileStat);
       totalHooks += result.hookCount;
@@ -177,11 +183,13 @@ export const runAudit = (targetDir = 'src', options = {}) => {
   const patternRegistry = createPatternRegistry();
   const hookRegistry = createHookShapeRegistry();
   const config = options.config || loadProjectConfig(cwd);
+  const includeTests = Boolean(options.includeTests);
   const { violations, fileStats, totalHooks } = scanTree(absoluteTarget, cwd, {
     patternRegistry,
     hookRegistry,
     fast: Boolean(options.fast),
     fileList: options.fileList || null,
+    includeTests,
     config
   });
 

package/cli/commands/cmd-audit.js

@@ -101,7 +101,8 @@ export const runAudit = async (customDir, isCli, rawArgs, loadProjectConfig) =>
     fileList = preflight.fileList;
   }
 
-  const auditOptions = { outputFile, model, costPerMillion, fast: isFast, fileList, stage, config: projectConfig };
+  const includeTests = rawArgs.includes('--include-tests') || rawArgs.includes('--tests');
+  const auditOptions = { outputFile, model, costPerMillion, fast: isFast, fileList, stage, config: projectConfig, includeTests };
   const report = executeAstAudit(targetDir, auditOptions);
   saveAuditSnapshot(report);
   try {
@@ -112,7 +113,8 @@ export const runAudit = async (customDir, isCli, rawArgs, loadProjectConfig) =>
       const shouldTriage = !rawArgs.includes('--no-triage');
       if (shouldTriage) {
         const createdTasks = autoGenerateTasksFromAudit(syncRes.db, { cwd: process.cwd(), targetDir });
-        if (isCli && !isJson && createdTasks.length > 0) {
+        const shouldLogTriage = isCli && !isJson && createdTasks.length > 0;
+        if (shouldLogTriage) {
           process.stdout.write(`\x1b[32m✔\x1b[0m Auto-triage synchronized ${createdTasks.length} team task(s) in SQLite backlog.\n`);
         }
       }
@@ -141,8 +143,8 @@ export const runAudit = async (customDir, isCli, rawArgs, loadProjectConfig) =>
         }
       }
     }
-  } catch {
-    // Gracefully bypass indexing when database is readonly in sandboxed environment
+  } catch (err) {
+    if (process.env.DEBUG) process.stderr.write(`[debug] Indexing bypassed: ${err?.message}\n`);
   }
 
   // Stage 1: Atomic failure predicates

package/cli/installer-templates.js

@@ -62,27 +62,47 @@ MIN_SCORE="\${CHEMX_MIN_SCORE:-\${CONF_MIN_SCORE:-${minScore}}}"
 MAX_LINES="\${CHEMX_MAX_LINES:-\${CONF_MAX_LINES:-500}}"
 MAX_MOLECULE_LINES="\${CHEMX_MAX_MOLECULE_LINES:-\${CONF_MAX_MOL:-100}}"
 
-STAGED_FILES=\$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(jsx?|tsx?|vue|svelte)\$' | grep -vE '(\\.(d\\.ts|min\\.|test\\.|spec\\.))')
+STAGED_FILES=\$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(jsx?|tsx?|vue|svelte|cs|py|go)\$' | grep -vE '(\\.(d\\.ts|min\\.|test\\.|spec\\.))')
 [ -z "\$STAGED_FILES" ] && exit 0
 
 FAILED=0
 ERRORS=""
+EXCEEDED_FILES=""
 for F in \$STAGED_FILES; do
   [ ! -f "\$F" ] && continue
   L=\$(wc -l < "\$F" | tr -d ' ')
   case "\$F" in
     *molecules*|*/m-*|m-*)
-      [ "\$L" -gt "\$MAX_MOLECULE_LINES" ] && FAILED=1 && ERRORS="\${ERRORS}\\n  \${C_RED}✕\${C_RESET} \$F (\$L LOC > \$MAX_MOLECULE_LINES molecule limit)" ;;
+      if [ "\$L" -gt "\$MAX_MOLECULE_LINES" ]; then
+        FAILED=1
+        ERRORS="\${ERRORS}\\n  \${C_RED}✕\${C_RESET} \$F (\$L LOC > \$MAX_MOLECULE_LINES molecule limit)"
+        EXCEEDED_FILES="\${EXCEEDED_FILES}\\n- \$F (\$L LOC > \$MAX_MOLECULE_LINES limit)"
+      fi
+      ;;
     *)
-      [ "\$L" -gt "\$MAX_LINES" ] && FAILED=1 && ERRORS="\${ERRORS}\\n  \${C_RED}✕\${C_RESET} \$F (\$L LOC > \$MAX_LINES file budget)" ;;
+      if [ "\$L" -gt "\$MAX_LINES" ]; then
+        FAILED=1
+        ERRORS="\${ERRORS}\\n  \${C_RED}✕\${C_RESET} \$F (\$L LOC > \$MAX_LINES file budget)"
+        EXCEEDED_FILES="\${EXCEEDED_FILES}\\n- \$F (\$L LOC > \$MAX_LINES limit)"
+      fi
+      ;;
   esac
 done
 
 if [ "\$FAILED" -eq 1 ]; then
   printf "\\n%s%s[Chemical X] Commit Blocked: Staged files exceed architectural line budgets%s\\n" "\$C_BOLD" "\$C_RED" "\$C_RESET"
   printf "%b\\n\\n" "\$ERRORS"
-  printf "%sMonolithic files degrade AI context windows and cause hallucination loops.%s\\n" "\$C_YELLOW" "\$C_RESET"
-  printf "Decompose large files into single-purpose crystalline capsules or configure thresholds in .chemx/config.json before committing.\\n\\n"
+  printf "%s╭──────────────────────────────────────────────────────────────────────────╮%s\\n" "\$C_CYAN" "\$C_RESET"
+  printf "%s│ 🤖 AI REFACTOR PROMPT (Copy & paste into your AI assistant):            │%s\\n" "\$C_CYAN" "\$C_RESET"
+  printf "%s╰──────────────────────────────────────────────────────────────────────────╯%s\\n" "\$C_CYAN" "\$C_RESET"
+  printf "Please refactor the following files that exceed Chemical X line budgets:%b\\n\\n" "\$EXCEEDED_FILES"
+  printf "Refactor Directives:\\n"
+  printf "1. Decompose monolithic logic into crystalline single-purpose modules (< %s lines for files, < %s lines for molecules).\\n" "\$MAX_LINES" "\$MAX_MOLECULE_LINES"
+  printf "2. Extract presentation into Table-of-Contents views and business state into composables/services.\\n"
+  printf "3. Preserve all existing symbols, exports, and public API contracts.\\n"
+  printf "4. Decompose complex inline booleans and flatten nested control flow.\\n"
+  printf "%s────────────────────────────────────────────────────────────────────────────%s\\n\\n" "\$C_CYAN" "\$C_RESET"
+  printf "%s💡 Tip: To bypass line budgets temporarily: CHEMX_SKIP_PRECOMMIT=1 git commit%s\\n\\n" "\$C_YELLOW" "\$C_RESET"
   exit 1
 fi
 
@@ -104,7 +124,18 @@ if [ -n "\$AUDIT_BIN" ]; then
   if ! AUDIT_OUT=\$(eval "\$AUDIT_BIN audit --git --min-grade=\$MIN_GRADE --min-score=\$MIN_SCORE --non-interactive" < /dev/null 2>&1); then
     printf "\\n%s%s[Chemical X] Commit Blocked: Architectural health verification failed%s\\n" "\$C_BOLD" "\$C_RED" "\$C_RESET"
     printf "%s\\n\\n" "\$AUDIT_OUT"
-    printf "%s💡 Tip: Want crystalline drop-in templates? Run 'npm create chemx' or sponsor at https://github.com/sponsors/Chemical-X-Protocol%s\\n\\n" "\$C_CYAN" "\$C_RESET"
+    printf "%s╭──────────────────────────────────────────────────────────────────────────╮%s\\n" "\$C_CYAN" "\$C_RESET"
+    printf "%s│ 🤖 AI REFACTOR PROMPT (Copy & paste into your AI assistant):            │%s\\n" "\$C_CYAN" "\$C_RESET"
+    printf "%s╰──────────────────────────────────────────────────────────────────────────╯%s\\n" "\$C_CYAN" "\$C_RESET"
+    printf "Please fix the Chemical X architectural hazards reported above in staged files.\\n\\n"
+    printf "Refactor Directives:\\n"
+    printf "1. Surgically resolve each flagged Critical and High severity hazard.\\n"
+    printf "2. Decompose monoliths into single-purpose crystalline capsules.\\n"
+    printf "3. Preserve all existing symbols, exports, and test contracts.\\n"
+    printf "4. Verify with 'chemx audit' after making changes.\\n"
+    printf "%s────────────────────────────────────────────────────────────────────────────%s\\n\\n" "\$C_CYAN" "\$C_RESET"
+    printf "%s💡 Tip: Run 'chemx audit' locally to inspect details or run autofixes.%s\\n" "\$C_CYAN" "\$C_RESET"
+    printf "   To bypass this check temporarily: CHEMX_SKIP_PRECOMMIT=1 git commit\\n\\n"
     exit 1
   fi
 fi

package/cli/languages.js

@@ -76,6 +76,14 @@ export const LANGUAGE_DEFINITIONS = {
     parser: 'jvm',
     commentPrefix: '//',
     blockComment: { start: '/*', end: '*/' }
+  },
+  cpp: {
+    id: 'cpp',
+    name: 'C / C++',
+    extensions: new Set(['.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh', '.inl']),
+    parser: 'cpp',
+    commentPrefix: '//',
+    blockComment: { start: '/*', end: '*/' }
   }
 };
 

package/cli/languages.spec.js

@@ -42,3 +42,24 @@ test('languages: resolves language metadata', () => {
   assert.equal(py.id, 'python');
   assert.equal(py.commentPrefix, '#');
 });
+
+test('languages: recognizes C and C++ source extensions', () => {
+  assert.equal(isSourceFile('StreamDecoder.cpp'), true);
+  assert.equal(isSourceFile('StreamDecoder.cc'), true);
+  assert.equal(isSourceFile('StreamDecoder.cxx'), true);
+  assert.equal(isSourceFile('StreamDecoder.hpp'), true);
+  assert.equal(isSourceFile('StreamDecoder.h'), true);
+  assert.equal(isSourceFile('legacy_shim.c'), true);
+});
+
+test('languages: maps C and C++ extensions to the cpp language', () => {
+  assert.equal(getLanguageForFile('StreamDecoder.cpp').id, 'cpp');
+  assert.equal(getLanguageForFile('StreamDecoder.h').id, 'cpp');
+  assert.equal(getLanguageForFile('legacy_shim.c').id, 'cpp');
+  assert.equal(LANGUAGE_DEFINITIONS.cpp.name, 'C / C++');
+});
+
+test('languages: C and C++ are not babel parsable', () => {
+  assert.equal(isBabelParsable('StreamDecoder.cpp'), false);
+  assert.equal(isBabelParsable('StreamDecoder.h'), false);
+});

package/cli/path-scope.js

@@ -61,3 +61,53 @@ export const isPathTraversal = (targetPath, baseDir = process.cwd()) => {
     return true;
   }
 };
+
+const hasDotNetProject = (cwd) => {
+  try {
+    const rootEntries = fs.readdirSync(cwd, { withFileTypes: true });
+    const hasSln = rootEntries.some((e) => e.isFile() && e.name.endsWith('.sln'));
+    const hasRootCsproj = rootEntries.some((e) => e.isFile() && e.name.endsWith('.csproj'));
+    if (hasSln || hasRootCsproj) return true;
+
+    return rootEntries.some((e) => {
+      const isCandidateDir = e.isDirectory() && e.name !== 'src' && e.name !== 'node_modules' && !e.name.startsWith('.');
+      if (!isCandidateDir) return false;
+      const subPath = path.join(cwd, e.name);
+      try {
+        return fs.readdirSync(subPath).some((f) => f.endsWith('.csproj'));
+      } catch (err) {
+        if (process.env.DEBUG) process.stderr.write(`[debug] Read failed: ${err?.message}\n`);
+        return false;
+      }
+    });
+  } catch (err) {
+    if (process.env.DEBUG) process.stderr.write(`[debug] Scan failed: ${err?.message}\n`);
+    return false;
+  }
+};
+
+export const resolveTargetDir = (customOrFlag = null, dirFlag = null, cwd = process.cwd()) => {
+  const isCustomPath = Boolean(customOrFlag && !customOrFlag.startsWith('--dir='));
+  if (isCustomPath) {
+    return customOrFlag;
+  }
+
+  const effectiveFlag = dirFlag || (customOrFlag?.startsWith('--dir=') ? customOrFlag : null);
+  if (effectiveFlag) {
+    const [, flagValue] = effectiveFlag.split('=');
+    if (flagValue !== undefined) {
+      return flagValue;
+    }
+  }
+
+  if (hasDotNetProject(cwd)) {
+    return '.';
+  }
+
+  const hasSrcDirectory = fs.existsSync(path.resolve(cwd, 'src'));
+  if (hasSrcDirectory) {
+    return 'src';
+  }
+
+  return '.';
+};

package/cli/polyglot.spec.js

@@ -109,3 +109,114 @@ func TestDummy(t *testing.T) {
   assert.equal(goViolations.some((v) => v.rule === 'SYNTAX_PARSE_ERROR'), false);
   assert.equal(goViolations.some((v) => v.rule === 'SYNTHETIC_MOCK_DATA'), true);
 });
+
+test('polyglot: extracts C++ classes, structs, functions and includes', () => {
+  const cppCode = `
+#include <memory>
+#include "vendor/codec.h"
+
+namespace audio {
+
+struct FrameHeader {
+    uint32_t size;
+};
+
+enum class Codec { Opus, Flac };
+
+class StreamDecoder : public IDecoder {
+public:
+    bool DecodeFrame(const FrameHeader& header);
+};
+
+bool StreamDecoder::DecodeFrame(const FrameHeader& header) {
+    return header.size > 0;
+}
+
+}  // namespace audio
+`;
+
+  const meta = extractAstMetadata(cppCode, 'src/audio/StreamDecoder.cpp');
+  const names = meta.symbols.map((s) => s.name);
+  assert.ok(names.includes('StreamDecoder'), 'must extract class StreamDecoder');
+  assert.ok(names.includes('FrameHeader'), 'must extract struct FrameHeader');
+  assert.ok(names.includes('Codec'), 'must extract enum class Codec');
+  assert.ok(names.includes('DecodeFrame'), 'must extract method DecodeFrame');
+  assert.ok(meta.imports.some((i) => i.sourceModule === 'vendor/codec.h'), 'must map #include to imports');
+  assert.ok(meta.imports.some((i) => i.sourceModule === 'memory'), 'must map angle-bracket includes');
+});
+
+test('polyglot: audits C++ without Babel syntax errors', () => {
+  const cppCode = `
+#include <string>
+void Connect() {
+    std::string email = "user@example.com";
+}
+`;
+  const violations = auditCode(cppCode, 'src/net/Client.cpp', 'src/net/Client.cpp');
+  assert.equal(violations.some((v) => v.rule === 'SYNTAX_PARSE_ERROR'), false, 'C++ must not trigger Babel SYNTAX_PARSE_ERROR');
+  assert.equal(violations.some((v) => v.rule === 'SYNTHETIC_MOCK_DATA'), true, 'must detect placeholder email in C++');
+});
+
+test('polyglot: extracts Rust items and use imports', () => {
+  const rustCode = `
+use std::sync::Arc;
+
+pub struct Decoder {
+    buffer: Vec<u8>,
+}
+
+pub enum State { Idle, Running }
+
+pub trait Sink {
+    fn write(&self, data: &[u8]);
+}
+
+impl Decoder {
+    pub fn new() -> Self { Decoder { buffer: Vec::new() } }
+}
+`;
+  const meta = extractAstMetadata(rustCode, 'src/decoder.rs');
+  const names = meta.symbols.map((s) => s.name);
+  assert.ok(names.includes('Decoder'), 'must extract pub struct');
+  assert.ok(names.includes('State'), 'must extract pub enum');
+  assert.ok(names.includes('Sink'), 'must extract pub trait');
+  assert.ok(names.includes('new'), 'must extract fn');
+  assert.ok(meta.imports.some((i) => i.sourceModule === 'std::sync::Arc'), 'must map use statements');
+});
+
+test('polyglot: extracts Kotlin declarations and imports', () => {
+  const kotlinCode = `
+import kotlinx.coroutines.flow.Flow
+
+class ConsentRepository(private val api: Api) {
+    fun observe(): Flow<List<Consent>> = api.stream()
+}
+
+data class Consent(val id: String)
+
+object Registry {
+    fun lookup(id: String) = id
+}
+`;
+  const meta = extractAstMetadata(kotlinCode, 'src/main/kotlin/ConsentRepository.kt');
+  const names = meta.symbols.map((s) => s.name);
+  assert.ok(names.includes('ConsentRepository'), 'must extract class');
+  assert.ok(names.includes('Consent'), 'must extract data class');
+  assert.ok(names.includes('Registry'), 'must extract object');
+  assert.ok(names.includes('observe'), 'must extract fun');
+  assert.ok(meta.imports.some((i) => i.sourceModule === 'kotlinx.coroutines.flow.Flow'), 'must map kotlin imports');
+});
+
+test('polyglot: declaration keywords never leak in as symbol names', () => {
+  const cppCode = `
+enum class Codec { Opus, Flac };
+struct Frame { int size; };
+namespace audio { }
+`;
+  const meta = extractAstMetadata(cppCode, 'src/audio/Codec.h');
+  const names = meta.symbols.map((s) => s.name);
+  assert.equal(names.includes('class'), false, 'bare "class" must not be extracted as a symbol');
+  assert.equal(names.includes('struct'), false, 'bare "struct" must not be extracted as a symbol');
+  assert.ok(names.includes('Codec'));
+  assert.ok(names.includes('Frame'));
+});

package/cli/search-ast.js

@@ -21,6 +21,17 @@ export const resolveArchitectureTier = (relativePath) => {
   return 'utility';
 };
 
+const CPP_NON_DECLARATION_KEYWORDS = new Set([
+  'if', 'for', 'while', 'switch', 'catch', 'return', 'sizeof', 'else', 'do', 'throw', 'new', 'delete'
+]);
+
+// Declaration keywords are never symbol names. Guards cross-language regex overlap,
+// e.g. the Rust `enum` pattern matching C++ `enum class Codec` and capturing `class`.
+const RESERVED_SYMBOL_NAMES = new Set([
+  'class', 'struct', 'enum', 'union', 'interface', 'object', 'fun', 'trait', 'impl', 'mod',
+  'namespace', 'typename', 'template', 'public', 'private', 'protected', 'static', 'const'
+]);
+
 const extractRegexFallback = (content, filePath = '') => {
   const symbols = [];
   const imports = [];
@@ -47,6 +58,49 @@ const extractRegexFallback = (content, filePath = '') => {
     symbols.push({ name: m[1], kind: 'function', isExport: true, startLine: 1, endLine: 1, signature: '' });
   }
 
+  const cppTypeMatches = content.matchAll(/\b(?:class|struct|union|enum(?:\s+class)?)\s+([A-Za-z_][A-Za-z0-9_]*)/g);
+  for (const m of cppTypeMatches) {
+    if (!RESERVED_SYMBOL_NAMES.has(m[1])) {
+      symbols.push({ name: m[1], kind: 'class', isExport: true, startLine: 1, endLine: 1, signature: '' });
+    }
+  }
+
+  const cppQualifiedMatches = content.matchAll(/\b[A-Za-z_][A-Za-z0-9_]*\s*::\s*([A-Za-z_~][A-Za-z0-9_]*)\s*\(/g);
+  for (const m of cppQualifiedMatches) {
+    symbols.push({ name: m[1], kind: 'function', isExport: true, startLine: 1, endLine: 1, signature: '' });
+  }
+
+  const cppDeclMatches = content.matchAll(/^[ \t]*(?:[A-Za-z_][A-Za-z0-9_:<>,*& \t]*?)\s+\*?([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*\)\s*(?:const\s*)?[;{]/gm);
+  for (const m of cppDeclMatches) {
+    if (!CPP_NON_DECLARATION_KEYWORDS.has(m[1])) {
+      symbols.push({ name: m[1], kind: 'function', isExport: true, startLine: 1, endLine: 1, signature: '' });
+    }
+  }
+
+  const rustMatches = content.matchAll(/\b(?:pub\s+)?(?:struct|enum|trait|impl|mod|fn)\s+([A-Za-z_][A-Za-z0-9_]*)/g);
+  for (const m of rustMatches) {
+    if (!RESERVED_SYMBOL_NAMES.has(m[1])) {
+      symbols.push({ name: m[1], kind: 'symbol', isExport: true, startLine: 1, endLine: 1, signature: '' });
+    }
+  }
+
+  const kotlinMatches = content.matchAll(/\b(?:data\s+|sealed\s+|open\s+|abstract\s+|inner\s+)?(?:class|object|interface|fun)\s+([A-Za-z_][A-Za-z0-9_]*)/g);
+  for (const m of kotlinMatches) {
+    if (!RESERVED_SYMBOL_NAMES.has(m[1])) {
+      symbols.push({ name: m[1], kind: 'symbol', isExport: true, startLine: 1, endLine: 1, signature: '' });
+    }
+  }
+
+  const cppIncludes = content.matchAll(/#include\s*[<"]([^>"]+)[>"]/g);
+  for (const m of cppIncludes) {
+    imports.push({ importedSymbol: '*', sourceModule: m[1], line: 1 });
+  }
+
+  const rustUses = content.matchAll(/\buse\s+([A-Za-z_][A-Za-z0-9_]*(?:::[A-Za-z_][A-Za-z0-9_]*)+)/g);
+  for (const m of rustUses) {
+    imports.push({ importedSymbol: '*', sourceModule: m[1], line: 1 });
+  }
+
   const csImports = content.matchAll(/using\s+([A-Za-z0-9_.]+);/g);
   for (const m of csImports) {
     imports.push({ importedSymbol: '*', sourceModule: m[1], line: 1 });

package/cli/search.d.ts

@@ -101,7 +101,8 @@ export declare function runSearch(
 
 export declare function resolveTargetDir(
   customOrFlag?: string | null,
-  dirFlag?: string | null
+  dirFlag?: string | null,
+  cwd?: string
 ): string;
 
 export declare function findSymbolDefinition(

package/cli/search.js

@@ -36,6 +36,7 @@ import {
 import { runGenerateWizard } from './generator.js';
 import { runMutatorCli } from './mutators.js';
 import { toColumnar } from './columnar.js';
+import { resolveTargetDir } from './path-scope.js';
 import { ANSI } from './theme.js';
 
 export { toColumnar, fromColumnar } from './columnar.js';
@@ -207,27 +208,7 @@ const formatTierBadge = (tier) => {
   return map[tier] || `${ANSI.DIM}[${tier}]${ANSI.RESET}`;
 };
 
-export const resolveTargetDir = (customOrFlag = null, dirFlag = null) => {
-  const isCustomPath = Boolean(customOrFlag && !customOrFlag.startsWith('--dir='));
-  if (isCustomPath) {
-    return customOrFlag;
-  }
-
-  const effectiveFlag = dirFlag || (customOrFlag?.startsWith('--dir=') ? customOrFlag : null);
-  if (effectiveFlag) {
-    const [, flagValue] = effectiveFlag.split('=');
-    if (flagValue !== undefined) {
-      return flagValue;
-    }
-  }
-
-  const hasSrcDirectory = fs.existsSync('src');
-  if (hasSrcDirectory) {
-    return 'src';
-  }
-
-  return '.';
-};
+export { resolveTargetDir };
 
 export const printSearchHelp = () => {
   const BOLD = '\x1b[1m';

package/cli/search.spec.js

@@ -57,6 +57,18 @@ test('resolveTargetDir: defaults to src if present, otherwise . when no flags pr
   assert.strictEqual(resultNoArgs, expectedDefault);
 });
 
+test('resolveTargetDir: defaults to . when .sln or csproj exists at repo root', () => {
+  const tmpDir = path.resolve('scratch/test-dotnet-repo');
+  fs.mkdirSync(tmpDir, { recursive: true });
+  fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(tmpDir, 'Solution.sln'), '', 'utf8');
+
+  const resolved = resolveTargetDir(null, null, tmpDir);
+  assert.strictEqual(resolved, '.');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
 test('search-db: indexes symbols with line ranges and finds definition', () => {
   const db = openIndexDb();
   if (!db) return;
@@ -265,3 +277,18 @@ test('hybrid search: natural language "toggle a task item" ranks useTaskListCont
   } catch {}
 });
 
+
+test('runSearch: resolveTargetDir is bound in module scope, not only re-exported', async () => {
+  const { runSearch } = await import('./search.js');
+  let caught = null;
+  try {
+    await runSearch(['__chemx_nonexistent_symbol__'], false);
+  } catch (err) {
+    caught = err;
+  }
+  assert.equal(
+    caught instanceof ReferenceError,
+    false,
+    `runSearch threw a ReferenceError: ${caught && caught.message}`
+  );
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chemx/starter-kit",
-  "version": "26.9.28-276",
+  "version": "26.10.4-235",
   "description": "Chemical X Protocol: Private drop-in architecture starter kit and capsule generator",
   "type": "module",
   "bin": {

package/scripts/pre-commit.sh

@@ -66,8 +66,8 @@ MIN_SCORE="${CHEMX_MIN_SCORE:-${CONF_MIN_SCORE:-80}}"
 MAX_LINES="${CHEMX_MAX_LINES:-${CONF_MAX_LINES:-500}}"
 MAX_MOLECULE_LINES="${CHEMX_MAX_MOLECULE_LINES:-${CONF_MAX_MOL:-100}}"
 
-# Detect staged source files
-STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(jsx?|tsx?|vue|svelte)$' | grep -vE '(\.d\.ts|\.min\.|\.test\.|\.spec\.)')
+# Detect staged source files (including polyglot C#, Python, Go)
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(jsx?|tsx?|vue|svelte|cs|py|go)$' | grep -vE '(\.(d\.ts|min\.|test\.|spec\.))')
 
 if [ -z "$STAGED_FILES" ]; then
   exit 0
@@ -75,6 +75,7 @@ fi
 
 LINE_BUDGET_FAILED=0
 LINE_BUDGET_ERRORS=""
+EXCEEDED_FILES=""
 
 for FILE in $STAGED_FILES; do
   if [ -f "$FILE" ]; then
@@ -86,12 +87,14 @@ for FILE in $STAGED_FILES; do
         if [ "$LINES" -gt "$MAX_MOLECULE_LINES" ]; then
           LINE_BUDGET_FAILED=1
           LINE_BUDGET_ERRORS="${LINE_BUDGET_ERRORS}\n  ${C_RED}✕${C_RESET} $FILE ($LINES LOC > $MAX_MOLECULE_LINES LOC molecule capsule limit)"
+          EXCEEDED_FILES="${EXCEEDED_FILES}\n- $FILE ($LINES LOC > $MAX_MOLECULE_LINES LOC molecule limit)"
         fi
         ;;
       *)
         if [ "$LINES" -gt "$MAX_LINES" ]; then
           LINE_BUDGET_FAILED=1
           LINE_BUDGET_ERRORS="${LINE_BUDGET_ERRORS}\n  ${C_RED}✕${C_RESET} $FILE ($LINES LOC > $MAX_LINES LOC file budget)"
+          EXCEEDED_FILES="${EXCEEDED_FILES}\n- $FILE ($LINES LOC > $MAX_LINES LOC file budget)"
         fi
         ;;
     esac
@@ -101,8 +104,17 @@ done
 if [ "$LINE_BUDGET_FAILED" -eq 1 ]; then
   printf "\n%s%s[Chemical X] Commit Blocked: Staged files exceed architectural line budgets%s\n" "$C_BOLD" "$C_RED" "$C_RESET"
   printf "%b\n\n" "$LINE_BUDGET_ERRORS"
-  printf "%sMonolithic files degrade AI context windows and cause hallucination loops.%s\n" "$C_YELLOW" "$C_RESET"
-  printf "Decompose large files into single-purpose crystalline capsules before committing.\n\n"
+  printf "%s╭──────────────────────────────────────────────────────────────────────────╮%s\n" "$C_CYAN" "$C_RESET"
+  printf "%s│ 🤖 AI REFACTOR PROMPT (Copy & paste into your AI assistant):            │%s\n" "$C_CYAN" "$C_RESET"
+  printf "%s╰──────────────────────────────────────────────────────────────────────────╯%s\n" "$C_CYAN" "$C_RESET"
+  printf "Please refactor the following files that exceed Chemical X line budgets:%b\n\n" "$EXCEEDED_FILES"
+  printf "Refactor Directives:\n"
+  printf "1. Decompose monolithic logic into single-purpose crystalline capsules or helper modules (< %s lines for files, < %s lines for molecules).\n" "$MAX_LINES" "$MAX_MOLECULE_LINES"
+  printf "2. Extract presentation into Table-of-Contents views and business state into composables/services.\n"
+  printf "3. Preserve all existing symbols, exports, and public API contracts.\n"
+  printf "4. Decompose complex inline booleans and flatten nested control flow.\n"
+  printf "%s────────────────────────────────────────────────────────────────────────────%s\n\n" "$C_CYAN" "$C_RESET"
+  printf "%s💡 Tip: To bypass line budgets temporarily: CHEMX_SKIP_PRECOMMIT=1 git commit%s\n\n" "$C_YELLOW" "$C_RESET"
   exit 1
 fi
 
@@ -127,8 +139,18 @@ if [ -n "$AUDIT_BIN" ]; then
   if ! AUDIT_OUT=$(eval "$AUDIT_CMD < /dev/null" 2>&1); then
     printf "\n%s%s[Chemical X] Commit Blocked: Architectural health verification failed%s\n" "$C_BOLD" "$C_RED" "$C_RESET"
     printf "%s\n\n" "$AUDIT_OUT"
-    printf "%s💡 Tip: Want crystalline drop-in templates to refactor in minutes?%s\n" "$C_CYAN" "$C_RESET"
-    printf "   Run 'npm create chemx' or sponsor at https://github.com/sponsors/Chemical-X-Protocol\n\n"
+    printf "%s╭──────────────────────────────────────────────────────────────────────────╮%s\n" "$C_CYAN" "$C_RESET"
+    printf "%s│ 🤖 AI REFACTOR PROMPT (Copy & paste into your AI assistant):            │%s\n" "$C_CYAN" "$C_RESET"
+    printf "%s╰──────────────────────────────────────────────────────────────────────────╯%s\n" "$C_CYAN" "$C_RESET"
+    printf "Please fix the Chemical X architectural hazards reported above in staged files.\n\n"
+    printf "Refactor Directives:\n"
+    printf "1. Surgically resolve each flagged Critical and High severity hazard.\n"
+    printf "2. Decompose monoliths into single-purpose crystalline capsules.\n"
+    printf "3. Preserve all existing symbols, exports, and test contracts.\n"
+    printf "4. Verify with 'chemx audit' after making changes.\n"
+    printf "%s────────────────────────────────────────────────────────────────────────────%s\n\n" "$C_CYAN" "$C_RESET"
+    printf "%s💡 Tip: Run 'chemx audit' locally to inspect details or run autofixes.%s\n" "$C_CYAN" "$C_RESET"
+    printf "   To bypass this check temporarily: CHEMX_SKIP_PRECOMMIT=1 git commit\n\n"
     exit 1
   fi
 fi