@ngockhoale/ukit 1.4.0 → 1.4.2

package/src/core/runInstallPipeline.js

@@ -12,7 +12,7 @@ import { summarizeDiff, toDiffRows } from './report.js';
 import { writeInstallMetadata } from './metadata.js';
 import { cleanupLegacyPaths, migrateLegacyRuntimeRoot } from './migrateLegacy.js';
 import { ensureGitignore } from './ensureGitignore.js';
-import { readJsonIfExists, removeFileOrLinkOnly, resolveProjectRelativePath } from './fileOps.js';
+import { cleanupEmptyParents, readJsonIfExists, removeFileOrLinkOnly, resolveProjectRelativePath } from './fileOps.js';
 
 const AUTO_PRUNE_OBSOLETE_PREFIXES = [
   '.claude/skills/',
@@ -57,41 +57,6 @@ function shouldAutoPruneObsoletePath(relativePath) {
     || AUTO_PRUNE_OBSOLETE_PREFIXES.some((prefix) => relativePath.startsWith(prefix));
 }
 
-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);
-  }
-}
-
 async function isTrackedManagedDirectoryTree({
   dirPath,
   projectRoot,

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.2',
     agent: 'claude-code',
     autonomy: {
       level: 'balanced',
@@ -112,6 +112,59 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       advisorEnabled: true,
       maxAdvisorCalls: 3,
     },
+    orchestration: {
+      enabled: true,
+      orchestratorModel: 'claude-sonnet-4-6',
+      advisorEnabled: true,
+      contracts: {
+        'tiny-fix': {
+          maxReadPasses: 0,
+          maxContextPulls: 0,
+          verificationPolicy: 'minimal-or-targeted',
+          completionRule: 'never-claim-done-without-write',
+          delegationPolicy: 'disallow',
+        },
+        'local-fix': {
+          maxReadPasses: 1,
+          maxContextPulls: 1,
+          verificationPolicy: 'targeted-if-covered',
+          completionRule: 'require-write',
+          delegationPolicy: 'disallow',
+        },
+        'local-build': {
+          maxReadPasses: 2,
+          maxContextPulls: 1,
+          verificationPolicy: 'targeted-if-covered',
+          completionRule: 'require-write',
+          delegationPolicy: 'disallow-by-default',
+        },
+        'find-cause': {
+          maxReadPassesBeforeReassess: 3,
+          verificationPolicy: 'root-cause-then-targeted',
+          completionRule: 'never-claim-fixed-without-write-and-verification',
+          delegationPolicy: 'allow-specialized-debug-lane',
+        },
+        'shared-edit': {
+          maxReadPasses: 2,
+          maxContextPulls: 2,
+          verificationPolicy: 'targeted-then-widen-on-risk',
+          completionRule: 'require-write-and-verification',
+          delegationPolicy: 'allow-qualified-sidecar',
+        },
+        'map-impact': {
+          maxReadPasses: 3,
+          maxContextPulls: 3,
+          verificationPolicy: 'impact-first-then-targeted-then-widen-on-risk',
+          completionRule: 'require-impact-evidence-before-edit-claim',
+          delegationPolicy: 'allow-impact-sidecar',
+        },
+        'review-release': {
+          verificationPolicy: 'evidence-first',
+          completionRule: 'report-findings-not-implementation',
+          delegationPolicy: 'allow-review-sidecar',
+        },
+      },
+    },
     memory: {
       enabled: true,
       autoCapture: true,
@@ -268,16 +321,27 @@ 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');
     pushPositiveNumberError(errors, config.router.maxAdvisorCalls, 'router.maxAdvisorCalls');
   }
 
+  if (!isPlainObject(config.orchestration)) {
+    errors.push('orchestration must be an object.');
+  } else {
+    pushBooleanError(errors, config.orchestration.enabled, 'orchestration.enabled');
+    pushNonEmptyStringError(errors, config.orchestration.orchestratorModel, 'orchestration.orchestratorModel');
+    pushBooleanError(errors, config.orchestration.advisorEnabled, 'orchestration.advisorEnabled');
+    if (!isPlainObject(config.orchestration.contracts)) {
+      errors.push('orchestration.contracts must be an object.');
+    }
+  }
+
   if (!isPlainObject(config.memory)) {
     errors.push('memory must be an object.');
   } else {
@@ -372,5 +436,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',