@ngockhoale/ukit 1.4.0 → 1.4.1

package/src/core/runtimeConfig.js

@@ -49,7 +49,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
   const safeOverrides = isPlainObject(overrides) ? overrides : {};
 
   return mergeObjects({
-    version: '1.4.0',
+    version: '1.4.1',
     agent: 'claude-code',
     autonomy: {
       level: 'balanced',
@@ -268,10 +268,10 @@ export function validateRuntimeConfig(config) {
     errors.push('router must be an object.');
   } else {
     pushBooleanError(errors, config.router.enabled, 'router.enabled');
-    if (typeof config.router.defaultModel !== 'string' || config.router.defaultModel.trim() == '') {
+    if (typeof config.router.defaultModel !== 'string' || config.router.defaultModel.trim() === '') {
       errors.push('router.defaultModel must be a non-empty string.');
     }
-    if (typeof config.router.advisorModel !== 'string' || config.router.advisorModel.trim() == '') {
+    if (typeof config.router.advisorModel !== 'string' || config.router.advisorModel.trim() === '') {
       errors.push('router.advisorModel must be a non-empty string.');
     }
     pushBooleanError(errors, config.router.advisorEnabled, 'router.advisorEnabled');
@@ -372,5 +372,9 @@ export async function inspectRuntimeConfig(projectRoot) {
 
 export async function loadRuntimeConfig(projectRoot) {
   const inspection = await inspectRuntimeConfig(projectRoot);
+  if (inspection.exists && !inspection.valid) {
+    console.warn(`[UKit] Invalid UKit runtime config: ${inspection.errors.join('; ')}`);
+    return buildDefaultRuntimeConfig();
+  }
   return inspection.config;
 }

package/src/core/token/index.js

@@ -30,6 +30,25 @@ export function estimateTokenCount(value) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
 
+export function normalizeLineForDedupe(line) {
+  return String(line ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+export function uniqueLines(lines) {
+  const seen = new Set();
+  const unique = [];
+  for (const line of lines) {
+    const trimmed = String(line ?? '').trim();
+    const normalized = normalizeLineForDedupe(trimmed);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    unique.push(trimmed);
+  }
+  return unique;
+}
+
 export function buildCompactMachineKey(prefix, payload = {}) {
   return `${prefix}:${crypto.createHash('sha256').update(JSON.stringify(payload)).digest('base64url')}`;
 }
@@ -47,7 +66,8 @@ function isStructuredLine(line) {
 function normalizeWhitespace(value) {
   return value
     .replace(/\s+\|\s+/g, ' | ')
-    .replace(/\s*[:;]\s*/g, ': ')
+    .replace(/\s*:\s*/g, ': ')
+    .replace(/\s*;\s*/g, '; ')
     .replace(/\s*,\s*/g, ', ')
     .replace(/\s+/g, ' ')
     .trim();

package/src/core/uninstall.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import {
+  cleanupEmptyParents,
   readJsonIfExists,
   removeLinkOrDir,
   removeLinkOnly,
@@ -8,41 +9,6 @@ import {
 } from './fileOps.js';
 import { removeGitignoreBlock } from './ensureGitignore.js';
 
-async function isDirEmpty(dirPath) {
-  try {
-    const entries = await fs.readdir(dirPath);
-    return entries.length === 0;
-  } catch {
-    return false;
-  }
-}
-
-async function cleanupEmptyParents(targetPath, projectRoot) {
-  let currentDir = path.dirname(targetPath);
-  const stopDir = path.resolve(projectRoot);
-
-  while (currentDir.startsWith(stopDir) && currentDir !== stopDir) {
-    let stat;
-    try {
-      stat = await fs.lstat(currentDir);
-    } catch {
-      currentDir = path.dirname(currentDir);
-      continue;
-    }
-
-    if (!stat.isDirectory()) {
-      break;
-    }
-
-    if (!(await isDirEmpty(currentDir))) {
-      break;
-    }
-
-    await fs.rmdir(currentDir);
-    currentDir = path.dirname(currentDir);
-  }
-}
-
 // Use lstat (not access) so broken symlinks are also detected as existing.
 async function pathExistsLstat(targetPath) {
   try {
@@ -134,7 +100,12 @@ export async function uninstallUkit({ projectRoot, dryRun = false }) {
   // An attacker (or confused user) could forge the file to trigger uninstall of
   // the hardcoded managed paths. Requiring 'tool: ukit' ensures the file was
   // written by the UKit installer, not created manually.
-  const installData = await readJsonIfExists(installMetaPath);
+  let installData;
+  try {
+    installData = await readJsonIfExists(installMetaPath);
+  } catch {
+    return { removed: 0, attempted: 0, wasInstalled: false };
+  }
   if (!installData || installData.tool !== 'ukit') {
     return { removed: 0, attempted: 0, wasInstalled: false };
   }
@@ -233,14 +204,20 @@ export async function uninstallUkit({ projectRoot, dryRun = false }) {
   // Clean up .gitignore block added during install
   await removeGitignoreBlock(projectRoot);
 
-  // Cleanup empty parent directories sequentially (order matters)
   let removed = 0;
+  const removedPaths = [];
   for (const { abs, didRemove } of results) {
     if (didRemove) {
       removed += 1;
-      await cleanupEmptyParents(abs, projectRoot);
+      removedPaths.push(abs);
     }
   }
 
+  const deepestRemovedPaths = [...new Set(removedPaths)]
+    .sort((left, right) => right.length - left.length);
+  for (const removedPath of deepestRemovedPaths) {
+    await cleanupEmptyParents(removedPath, projectRoot);
+  }
+
   return { removed, attempted: allEntries.length, wasInstalled: true };
 }

package/src/index/buildIndex.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 
-import { getArtifactPath, getIndexDir, INDEX_ARTIFACTS, INDEX_SCHEMA_VERSION, normalizeRelative } from './paths.js';
+import { getArtifactPath, getIndexDir, INDEX_ARTIFACTS, INDEX_SCHEMA_VERSION, isLikelyTestFilePath, normalizeRelative } from './paths.js';
 import { importsNeedAliasContext, loadImportAliasContextState, resolveImportSpecifier } from './importResolution.js';
 import { clearIndexArtifactCache } from './queryIndex.js';
 import { clearRelatedTestArtifactCache } from './relatedTests.js';
@@ -466,16 +466,163 @@ async function collectFiles(scanRoots) {
   return result;
 }
 
+
+function stripCommentsStringAware(content) {
+  let result = '';
+  let state = 'normal';
+  let escaped = false;
+  let templateExpressionDepth = 0;
+  let regexCharClass = false;
+
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1];
+
+    if (state === 'line-comment') {
+      if (char === '\n') {
+        result += char;
+        state = 'normal';
+      }
+      continue;
+    }
+
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'normal';
+      }
+      continue;
+    }
+
+    result += char;
+
+    if (state === 'single' || state === 'double' || state === 'template' || state === 'regex') {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (state === 'single' && char === "'") state = 'normal';
+      if (state === 'double' && char === '"') state = 'normal';
+      if (state === 'template') {
+        if (char === '`' && templateExpressionDepth === 0) state = 'normal';
+        else if (char === '{' && content[index - 1] === '$') templateExpressionDepth += 1;
+        else if (char === '}' && templateExpressionDepth > 0) templateExpressionDepth -= 1;
+      }
+      if (state === 'regex') {
+        if (char === '[') regexCharClass = true;
+        else if (char === ']') regexCharClass = false;
+        else if (char === '/' && !regexCharClass) state = 'normal';
+      }
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      result = result.slice(0, -1);
+      state = 'line-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      result = result.slice(0, -1);
+      state = 'block-comment';
+      index += 1;
+      continue;
+    }
+    if (char === "'") state = 'single';
+    else if (char === '"') state = 'double';
+    else if (char === '`') state = 'template';
+    else if (char === '/' && isRegexLiteralStart(result.slice(0, -1))) {
+      state = 'regex';
+      regexCharClass = false;
+    }
+  }
+
+  return result;
+}
+
+function isRegexLiteralStart(prefix) {
+  const trimmed = prefix.trimEnd();
+  return !trimmed || /(?:[=(:,!&|?{};\[\n]|\b(?:return|throw|case|delete|typeof|void|new|in|of|yield|await)\s*)$/.test(trimmed);
+}
+
+function findScriptClose(content, startIndex) {
+  const lower = content.toLowerCase();
+  let state = 'normal';
+  let escaped = false;
+  let templateExpressionDepth = 0;
+
+  for (let index = startIndex; index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1];
+
+    if (state === 'line-comment') {
+      if (char === '\n') state = 'normal';
+      continue;
+    }
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'normal';
+      }
+      continue;
+    }
+    if (state === 'single' || state === 'double' || state === 'template') {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (state === 'single' && char === "'") state = 'normal';
+      else if (state === 'double' && char === '"') state = 'normal';
+      else if (state === 'template') {
+        if (char === '`' && templateExpressionDepth === 0) state = 'normal';
+        else if (char === '{' && content[index - 1] === '$') templateExpressionDepth += 1;
+        else if (char === '}' && templateExpressionDepth > 0) templateExpressionDepth -= 1;
+      }
+      continue;
+    }
+
+    if (lower.startsWith('</script>', index)) return index;
+    if (char === '/' && next === '/') {
+      state = 'line-comment';
+      index += 1;
+    } else if (char === '/' && next === '*') {
+      state = 'block-comment';
+      index += 1;
+    } else if (char === "'") state = 'single';
+    else if (char === '"') state = 'double';
+    else if (char === '`') state = 'template';
+  }
+
+  return -1;
+}
+
 function extractScriptContent(filePath, content) {
   if (!filePath.endsWith('.vue')) {
     return content;
   }
 
-  const allMatches = [...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/gi)];
-  if (allMatches.length === 0) return '';
-  return allMatches.map((m) => m[1]).join('\n');
+  const scripts = [];
+  const startTagPattern = /<script[^>]*>/gi;
+  for (const match of content.matchAll(startTagPattern)) {
+    const bodyStart = match.index + match[0].length;
+    const bodyEnd = findScriptClose(content, bodyStart);
+    if (bodyEnd !== -1) {
+      scripts.push(content.slice(bodyStart, bodyEnd));
+    }
+  }
+  if (scripts.length === 0) return '';
+  return scripts.join('\n');
 }
 
+
 function extractSymbols(filePath, content) {
   const symbols = [];
   const addSymbol = (name, type) => {
@@ -529,13 +676,10 @@ function extractSymbols(filePath, content) {
 }
 
 function extractImports(filePath, content) {
-  // Strip comments to avoid false-positive imports from commented-out code
-  const stripped = content
-    .replace(/\/\*[\s\S]*?\*\//g, '')  // block comments
-    .replace(/\/\/.*$/gm, '');              // line comments
+  const stripped = stripCommentsStringAware(content);
   const imports = [];
 
-  for (const match of stripped.matchAll(/import\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]/g)) {
+  for (const match of stripped.matchAll(/(?:^|[;\n])\s*import\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]/g)) {
     imports.push({
       from: filePath,
       to: match[1],
@@ -559,7 +703,7 @@ function extractImports(filePath, content) {
     });
   }
 
-  for (const match of stripped.matchAll(/export\s+(?:type\s+)?\{[^}]+\}\s+from\s+['"]([^'"]+)['"]/g)) {
+  for (const match of stripped.matchAll(/(?:^|[;\n])\s*export\s+(?:type\s+)?\{[^}]+\}\s+from\s+['"]([^'"]+)['"]/g)) {
     imports.push({
       from: filePath,
       to: match[1],
@@ -567,7 +711,7 @@ function extractImports(filePath, content) {
     });
   }
 
-  for (const match of stripped.matchAll(/export\s+\*(?:\s+as\s+[A-Za-z_$][A-Za-z0-9_$]*)?\s+from\s+['"]([^'"]+)['"]/g)) {
+  for (const match of stripped.matchAll(/(?:^|[;\n])\s*export\s+\*(?:\s+as\s+[A-Za-z_$][A-Za-z0-9_$]*)?\s+from\s+['"]([^'"]+)['"]/g)) {
     imports.push({
       from: filePath,
       to: match[1],
@@ -629,18 +773,71 @@ function extractFunctionBlocks(content) {
 
 function sliceBalancedBlock(content, startIndex) {
   let depth = 1;
+  let state = 'normal';
+  let escaped = false;
+  let templateExpressionDepth = 0;
+
   for (let index = startIndex; index < content.length; index += 1) {
     const char = content[index];
-    if (char === '{') {
-      depth += 1;
+    const next = content[index + 1];
+
+    if (state === 'line-comment') {
+      if (char === '\n') state = 'normal';
+      continue;
+    }
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'normal';
+      }
+      continue;
     }
-    if (char === '}') {
-      depth -= 1;
+    if (state === 'single' || state === 'double' || state === 'template') {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (state === 'single' && char === "'") state = 'normal';
+      else if (state === 'double' && char === '"') state = 'normal';
+      else if (state === 'template') {
+        if (char === '`' && templateExpressionDepth === 0) state = 'normal';
+        else if (char === '{' && content[index - 1] === '$') templateExpressionDepth += 1;
+        else if (char === '}' && templateExpressionDepth > 0) templateExpressionDepth -= 1;
+      }
+      continue;
     }
-    if (depth === 0) {
-      return content.slice(startIndex, index);
+
+    if (char === '/' && next === '/') {
+      state = 'line-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      state = 'block-comment';
+      index += 1;
+      continue;
     }
+    if (char === "'") {
+      state = 'single';
+      continue;
+    }
+    if (char === '"') {
+      state = 'double';
+      continue;
+    }
+    if (char === '`') {
+      state = 'template';
+      continue;
+    }
+    if (char === '{') depth += 1;
+    if (char === '}') depth -= 1;
+    if (depth === 0) return content.slice(startIndex, index);
   }
+
   return '';
 }
 
@@ -666,8 +863,8 @@ function extractFunctionCalls(filePath, content) {
 }
 
 function buildTestsMap(fileRecords) {
-  const testFiles = fileRecords.filter((file) => isLikelyTestFile(file.filePath));
-  const sourceFiles = fileRecords.filter((file) => CODE_EXTENSIONS.has(file.ext) && !isLikelyTestFile(file.filePath));
+  const testFiles = fileRecords.filter((file) => isLikelyTestFilePath(file.filePath));
+  const sourceFiles = fileRecords.filter((file) => CODE_EXTENSIONS.has(file.ext) && !isLikelyTestFilePath(file.filePath));
 
   return sourceFiles.map((sourceFile) => {
     const matches = testFiles
@@ -771,35 +968,6 @@ function shouldSkipDirectory(name) {
   return name.startsWith('.') && name !== '.claude' && name !== '.codex' && name !== '.antigravity';
 }
 
-function isLikelyTestFile(filePath) {
-  const lower = filePath.toLowerCase();
-  return (
-    lower.startsWith('__tests__/')
-    || lower.startsWith('test/')
-    || lower.startsWith('tests/')
-    || lower.startsWith('spec/')
-    || lower.startsWith('specs/')
-    || lower.includes('/__tests__/')
-    || lower.includes('/test/')
-    || lower.includes('/spec/')
-    || lower.includes('/specs/')
-    || lower.endsWith('.test.js')
-    || lower.endsWith('.test.ts')
-    || lower.endsWith('.test.vue')
-    || lower.endsWith('.test.tsx')
-    || lower.endsWith('.test.jsx')
-    || lower.endsWith('.test.mjs')
-    || lower.endsWith('.test.cjs')
-    || lower.endsWith('.spec.js')
-    || lower.endsWith('.spec.ts')
-    || lower.endsWith('.spec.vue')
-    || lower.endsWith('.spec.tsx')
-    || lower.endsWith('.spec.jsx')
-    || lower.endsWith('.spec.mjs')
-    || lower.endsWith('.spec.cjs')
-  );
-}
-
 function createSourceFingerprint(rootDir, discoveredFiles) {
   const hash = crypto.createHash('sha256');
   const normalizedEntries = discoveredFiles
@@ -985,7 +1153,7 @@ function classifyArchetypes(fileRecords, symbols) {
   return fileRecords
     .filter((f) => CODE_EXTENSIONS.has(f.ext))
     .map((file) => {
-      if (isLikelyTestFile(file.filePath)) {
+      if (isLikelyTestFilePath(file.filePath)) {
         return {
           filePath: file.filePath,
           archetype: 'test',

package/src/index/gitHooks.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import { escapeRegExp } from '../core/fileOps.js';
+
 const HOOK_NAMES = ['post-commit', 'post-merge', 'post-checkout'];
 const BEGIN = '# UKit index auto-refresh (begin)';
 const END = '# UKit index auto-refresh (end)';
@@ -17,12 +19,13 @@ export async function installIndexRefreshHooks({ projectRoot }) {
     const existing = await readTextOrEmpty(hookPath);
     const base = existing || '#!/bin/sh\n';
 
-    if (hasManagedBlock(base)) {
+    if (hasCompleteManagedBlock(base)) {
       unchanged += 1;
       continue;
     }
 
-    const next = `${base.trimEnd()}\n\n${buildManagedBlock()}\n`;
+    const cleanedBase = removeManagedBlockFragments(base);
+    const next = `${cleanedBase.trimEnd()}\n\n${buildManagedBlock()}\n`;
     await fs.writeFile(hookPath, next, { mode: 0o755 });
     await fs.chmod(hookPath, 0o755);
     installed += 1;
@@ -45,7 +48,7 @@ export async function removeIndexRefreshHooks({ projectRoot }) {
   for (const hookName of HOOK_NAMES) {
     const hookPath = path.join(hooksDir, hookName);
     const existing = await readTextOrEmpty(hookPath);
-    if (!existing || !hasManagedBlock(existing)) {
+    if (!existing || !hasCompleteManagedBlock(existing)) {
       unchanged += 1;
       continue;
     }
@@ -75,8 +78,10 @@ function buildManagedBlock() {
   ].join('\n');
 }
 
-function hasManagedBlock(content) {
-  return content.includes(BEGIN) && content.includes(END);
+function hasCompleteManagedBlock(content) {
+  const beginIndex = content.indexOf(BEGIN);
+  const endIndex = content.indexOf(END, beginIndex + BEGIN.length);
+  return beginIndex >= 0 && endIndex > beginIndex;
 }
 
 function removeManagedBlock(content) {
@@ -84,8 +89,28 @@ function removeManagedBlock(content) {
   return content.replace(pattern, '').replace(/\n{3,}/g, '\n\n');
 }
 
-function escapeRegExp(input) {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function removeManagedBlockFragments(content) {
+  const lines = content.split('\n');
+  const kept = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    if (line === BEGIN) {
+      skipping = true;
+      continue;
+    }
+
+    if (line === END) {
+      skipping = false;
+      continue;
+    }
+
+    if (!skipping) {
+      kept.push(line);
+    }
+  }
+
+  return kept.join('\n').replace(/\n{3,}/g, '\n\n');
 }
 
 async function ensureHooksDir(hooksDir) {

package/src/index/impactContext.js

@@ -38,6 +38,17 @@ function unique(values = []) {
   return [...new Set(values.filter(Boolean))];
 }
 
+function dedupeCallers(callers = []) {
+  const byKey = new Map();
+  for (const caller of callers) {
+    const key = `${caller.filePath}\0${caller.symbol}`;
+    if (!byKey.has(key)) {
+      byKey.set(key, caller);
+    }
+  }
+  return [...byKey.values()];
+}
+
 function resolveImportTarget(fromFilePath, specifier) {
   const from = normalizePath(fromFilePath);
   const to = String(specifier ?? '').trim();
@@ -119,10 +130,7 @@ export async function resolveImpactContext({
         continue;
       }
 
-      if (
-        changedFileSet.has(normalizePath(record.filePath))
-        && changedSymbolSet.has(record.symbol)
-      ) {
+      if (changedFileSet.has(normalizePath(record.filePath))) {
         continue;
       }
 
@@ -161,13 +169,15 @@ export async function resolveImpactContext({
     ...risk.riskLabels.flatMap((label) => RISK_TEST_RECOMMENDATIONS[label] ?? []),
   ]);
 
+  const dedupedCallers = dedupeCallers(callers).slice(0, budget.maxCallers);
+
   return {
     changedFiles: normalizedChangedFiles,
     changedSymbols: normalizedChangedSymbols,
     riskLabels: risk.riskLabels,
     requiresImpactCheck: risk.requiresImpactCheck,
     callees: unique(callees.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallees),
-    callers: unique(callers.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallers),
+    callers: dedupedCallers,
     importers: unique(importers).slice(0, budget.maxImporters),
     dependencies: unique(dependencies).slice(0, budget.maxImporters),
     mirrorCounterparts,
@@ -175,7 +185,7 @@ export async function resolveImpactContext({
     recommendedTestFiles,
     explanations: {
       callees: changedRecords.map((record) => `${record.filePath}:${record.symbol}`),
-      callers: callers.map((entry) => `${entry.filePath}:${entry.symbol}`),
+      callers: dedupedCallers.map((entry) => `${entry.filePath}:${entry.symbol}`),
       importers,
       relatedTests,
       mirrorCounterparts: mirrorCounterparts.map((entry) => `${entry.source} -> ${entry.filePath}`),