@ngockhoale/ukit 1.1.6 → 1.1.8

package/templates/.claude/ukit/index/lib/index-core.mjs

@@ -31,12 +31,16 @@ const INDEX_SCHEMA_VERSION = 6;
 export const DEFAULT_INDEX_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const INDEX_PARSE_BATCH_SIZE = 8;
 const MAX_IMPORTER_HOPS = 2;
+const CALL_IGNORE_WORDS = new Set([
+  'if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof',
+]);
 
 export const INDEX_ARTIFACTS = {
   meta: 'meta.json',
   files: 'files.json',
   symbols: 'symbols.json',
   imports: 'imports.json',
+  calls: 'calls.json',
   testsMap: 'tests-map.json',
   hotspots: 'hotspots.json',
   archetypes: 'archetypes.json',
@@ -159,6 +163,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
   const codeFiles = fileRecords.filter((f) => CODE_EXTENSIONS.has(f.ext));
   const symbols = [];
   const imports = [];
+  const calls = [];
   const reusableCodeFiles = [];
   let filesToParse = [];
   let reusedCodeFileCount = 0;
@@ -179,20 +184,24 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
   }
 
   if (reusableCodeFiles.length > 0) {
-    const [previousSymbolsArtifact, previousImportsArtifact] = await Promise.all([
+    const [previousSymbolsArtifact, previousImportsArtifact, previousCallsArtifact] = await Promise.all([
       readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.symbols),
       readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.imports),
+      readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.calls),
     ]);
     canReuseParsedArtifacts = previousSymbolsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION
-      && previousImportsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION;
+      && previousImportsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION
+      && previousCallsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION;
 
     if (canReuseParsedArtifacts) {
       const previousSymbolsByPath = groupBy(previousSymbolsArtifact.items ?? [], (item) => item.filePath);
       const previousImportsByPath = groupBy(previousImportsArtifact.items ?? [], (item) => item.from);
+      const previousCallsByPath = groupBy(previousCallsArtifact.items ?? [], (item) => item.filePath);
 
       for (const filePath of reusableCodeFiles) {
         symbols.push(...(previousSymbolsByPath.get(filePath) ?? []));
         imports.push(...(previousImportsByPath.get(filePath) ?? []));
+        calls.push(...(previousCallsByPath.get(filePath) ?? []));
         reusedCodeFileCount += 1;
       }
     } else {
@@ -215,6 +224,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
             ...extractImports(filePath, scriptContent),
             ...extractSupplementalImports(filePath, content),
           ],
+          calls: extractFunctionCalls(filePath, scriptContent),
         };
       } catch {
         return null;
@@ -224,6 +234,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
     for (const parsedFile of parsedBatch) {
       symbols.push(...parsedFile.symbols);
       imports.push(...parsedFile.imports);
+      calls.push(...parsedFile.calls);
     }
   }
 
@@ -329,6 +340,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
   if (!canReuseAllParsedArtifacts) {
     await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.symbols, { schemaVersion: INDEX_SCHEMA_VERSION, generatedAt, items: symbols });
     await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.imports, { schemaVersion: INDEX_SCHEMA_VERSION, generatedAt, items: imports });
+    await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.calls, { schemaVersion: INDEX_SCHEMA_VERSION, generatedAt, items: calls });
   }
   if (!canReuseTestsMap) {
     await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.testsMap, { schemaVersion: INDEX_SCHEMA_VERSION, generatedAt, items: testsMap });
@@ -559,6 +571,7 @@ function escapeJsonString(value) {
 const TASK_TYPE_BUDGETS = {
   trivial: { minFiles: 1, maxFiles: 2 },
   simple: { minFiles: 2, maxFiles: 5 },
+  'shared-simple': { minFiles: 3, maxFiles: 8 },
   'non-trivial': { minFiles: 4, maxFiles: 8 },
 };
 
@@ -1663,6 +1676,69 @@ function extractSupplementalImports(filePath, content) {
   return out;
 }
 
+function extractFunctionBlocks(content) {
+  const blocks = [];
+  const seenStarts = new Set();
+
+  for (const match of content.matchAll(/export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/g)) {
+    blocks.push({ symbol: match[1], exported: true, bodyStart: match.index + match[0].length });
+    seenStarts.add(match.index);
+  }
+
+  for (const match of content.matchAll(/(?:^|[^\w$])(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/g)) {
+    if (seenStarts.has(match.index + (match[1] ? 0 : 0))) {
+      continue;
+    }
+    blocks.push({ symbol: match[1], exported: false, bodyStart: match.index + match[0].length });
+  }
+
+  for (const match of content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*\{/g)) {
+    blocks.push({ symbol: match[1], exported: /^export\s+/.test(match[0]), bodyStart: match.index + match[0].length });
+  }
+
+  return blocks
+    .map((block) => ({ ...block, body: sliceBalancedBlock(content, block.bodyStart) }))
+    .filter((block) => block.body);
+}
+
+function sliceBalancedBlock(content, startIndex) {
+  let depth = 1;
+  for (let index = startIndex; index < content.length; index += 1) {
+    const char = content[index];
+    if (char === '{') {
+      depth += 1;
+    }
+    if (char === '}') {
+      depth -= 1;
+    }
+    if (depth === 0) {
+      return content.slice(startIndex, index);
+    }
+  }
+  return '';
+}
+
+function extractFunctionCalls(filePath, content) {
+  return extractFunctionBlocks(content).map((block) => {
+    const calls = [];
+    for (const match of block.body.matchAll(/(?:\b|\.)([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g)) {
+      const name = match[1];
+      if (!name || CALL_IGNORE_WORDS.has(name)) {
+        continue;
+      }
+      if (!calls.includes(name)) {
+        calls.push(name);
+      }
+    }
+    return {
+      filePath,
+      symbol: block.symbol,
+      exported: block.exported,
+      calls,
+    };
+  });
+}
+
 function buildTestsMap(fileRecords) {
   const tests = fileRecords.filter((x) => isLikelyTestFile(x.filePath));
   const sources = fileRecords.filter((x) => CODE_EXTENSIONS.has(x.ext) && !isLikelyTestFile(x.filePath));
@@ -2751,6 +2827,280 @@ async function detectPackageManager(rootDir) {
   return 'npm';
 }
 
+const IMPACT_SHARED_PATTERNS = [
+  { regex: /^src\/index\//, label: 'shared-index-runtime' },
+  {
+    regex: /^src\/core\/(runInstallPipeline|applyPlan|buildPlan|diffPlan|metadata|migrateLegacy|uninstall|runtimeConfig|runtimePaths)\.js$/,
+    label: 'shared-install-runtime',
+  },
+  { regex: /^src\/core\/(output|token|compact)\//, label: 'shared-token-runtime' },
+  { regex: /^templates\/\.claude\/hooks\//, label: 'installed-hook-runtime' },
+  { regex: /^templates\/\.claude\/ukit\//, label: 'installed-helper-runtime' },
+  { regex: /^manifests\/platform\.full\.yaml$/, label: 'install-manifest' },
+  { regex: /^templates\//, label: 'published-template-surface' },
+];
+
+const IMPACT_MIRROR_PAIRS = [
+  {
+    source: 'src/index/buildIndex.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds source index behavior',
+  },
+  {
+    source: 'src/index/queryIndex.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds source query behavior',
+  },
+  {
+    source: 'src/index/resolveContext.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds context resolution behavior',
+  },
+  {
+    source: 'src/index/verificationPlan.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds verification planning behavior',
+  },
+  {
+    source: 'src/index/taskRouting.js',
+    mirror: 'templates/.claude/ukit/index/route-task.mjs',
+    reason: 'installed route-task helper mirrors source task routing behavior',
+  },
+  {
+    source: 'src/index/routeCatalog.js',
+    mirror: 'templates/.claude/ukit/index/route-catalog.mjs',
+    reason: 'installed route catalog must match source route catalog',
+  },
+  {
+    source: 'src/core/output/index.js',
+    mirror: 'templates/.claude/ukit/runtime/output-compression.mjs',
+    reason: 'source output compression runtime should stay aligned with installed hook runtime',
+  },
+  {
+    source: 'src/core/token/index.js',
+    mirror: 'templates/.claude/ukit/runtime/token-utils.mjs',
+    reason: 'source token runtime should stay aligned with installed token utilities',
+  },
+  {
+    source: 'src/core/compact/threshold.js',
+    mirror: 'templates/.claude/ukit/runtime/compact-threshold.mjs',
+    reason: 'source compact threshold runtime should stay aligned with installed compact threshold hook',
+  },
+];
+
+const IMPACT_RISK_TEST_RECOMMENDATIONS = {
+  'shared-index-runtime': ['tests/index/indexing.test.js', 'tests/index/taskRouting.test.js'],
+  'shared-install-runtime': ['tests/integration/installPipeline.test.js'],
+  'installed-hook-runtime': ['tests/hooks/skillRouterHook.test.js', 'tests/integration/installPipeline.test.js'],
+  'published-template-surface': ['tests/integration/packageArtifact.test.js', 'tests/integration/installPipeline.test.js'],
+  'install-manifest': ['tests/integration/packageArtifact.test.js', 'tests/integration/installPipeline.test.js'],
+};
+
+const DEFAULT_IMPACT_LIMITS = {
+  maxCallers: 8,
+  maxCallees: 8,
+  maxImporters: 8,
+  maxTests: 8,
+  maxMirrors: 4,
+};
+
+function normalizeImpactPath(filePath) {
+  return String(filePath ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function uniqueImpact(values = []) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function classifyImpactRisk(filePaths = []) {
+  const normalizedPaths = uniqueImpact(filePaths.map(normalizeImpactPath));
+  const riskLabels = [];
+
+  for (const filePath of normalizedPaths) {
+    for (const entry of IMPACT_SHARED_PATTERNS) {
+      if (entry.regex.test(filePath) && !riskLabels.includes(entry.label)) {
+        riskLabels.push(entry.label);
+      }
+    }
+  }
+
+  return {
+    changedFiles: normalizedPaths,
+    riskLabels,
+    requiresImpactCheck: riskLabels.length > 0,
+  };
+}
+
+function findMirrorCounterparts(filePaths = []) {
+  const normalizedSet = new Set(filePaths.map(normalizeImpactPath).filter(Boolean));
+  const counterparts = [];
+
+  for (const pair of IMPACT_MIRROR_PAIRS) {
+    if (normalizedSet.has(pair.source)) {
+      counterparts.push({ filePath: pair.mirror, reason: pair.reason, source: pair.source });
+    }
+    if (normalizedSet.has(pair.mirror)) {
+      counterparts.push({ filePath: pair.source, reason: pair.reason, source: pair.mirror });
+    }
+  }
+
+  return counterparts.filter((entry, index, list) => (
+    list.findIndex((candidate) => candidate.filePath === entry.filePath && candidate.source === entry.source) === index
+  ));
+}
+
+function resolveImpactImportTargets(fromFilePath, specifier) {
+  const from = normalizeImpactPath(fromFilePath);
+  const to = String(specifier ?? '').trim();
+  if (!from || !to || !to.startsWith('.')) {
+    return [];
+  }
+
+  const fromDir = path.posix.dirname(from);
+  const base = path.posix.normalize(path.posix.join(fromDir, to));
+  return uniqueImpact([
+    base,
+    `${base}.js`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.jsx`,
+    `${base}.vue`,
+    path.posix.join(base, 'index.js'),
+    path.posix.join(base, 'index.ts'),
+    path.posix.join(base, 'index.mjs'),
+  ]);
+}
+
+export async function resolveImpactContext({
+  rootDir = process.cwd(),
+  changedFiles = [],
+  changedSymbols = [],
+  limits = {},
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const budget = { ...DEFAULT_IMPACT_LIMITS, ...(limits ?? {}) };
+  const normalizedChangedFiles = uniqueImpact(changedFiles.map(normalizeImpactPath));
+  const normalizedChangedSymbols = uniqueImpact(changedSymbols.map((symbol) => String(symbol ?? '').trim()));
+
+  const [callsArtifact, importsArtifact, relatedArtifacts] = await Promise.all([
+    readArtifact(absoluteRoot, INDEX_ARTIFACTS.calls),
+    readArtifact(absoluteRoot, INDEX_ARTIFACTS.imports),
+    loadRelatedTestArtifacts({ rootDir: absoluteRoot }),
+  ]);
+
+  const callItems = callsArtifact.items ?? [];
+  const importItems = importsArtifact.items ?? [];
+  const risk = classifyImpactRisk(normalizedChangedFiles);
+  const mirrorCounterparts = findMirrorCounterparts(normalizedChangedFiles).slice(0, budget.maxMirrors);
+  const changedFileSet = new Set(normalizedChangedFiles);
+  const changedSymbolSet = new Set(normalizedChangedSymbols);
+  const changedRecords = callItems.filter((item) => {
+    const fileMatched = changedFileSet.has(normalizeImpactPath(item.filePath));
+    if (!fileMatched) return false;
+    return changedSymbolSet.size === 0 || changedSymbolSet.has(item.symbol);
+  });
+
+  const callees = [];
+  for (const record of changedRecords) {
+    for (const symbol of record.calls ?? []) {
+      callees.push({ filePath: record.filePath, fromSymbol: record.symbol, symbol });
+    }
+  }
+
+  const callers = [];
+  const callerTargets = new Set([
+    ...normalizedChangedSymbols,
+    ...changedRecords.map((record) => record.symbol),
+  ]);
+  if (callerTargets.size > 0) {
+    for (const record of callItems) {
+      const matchedSymbol = (record.calls ?? []).find((name) => callerTargets.has(name));
+      if (!matchedSymbol) continue;
+      if (changedFileSet.has(normalizeImpactPath(record.filePath)) && changedSymbolSet.has(record.symbol)) continue;
+      callers.push({ filePath: record.filePath, symbol: record.symbol, reason: `calls ${matchedSymbol}` });
+    }
+  }
+
+  const importers = [];
+  const dependencies = [];
+  for (const imp of importItems) {
+    const from = normalizeImpactPath(imp.from);
+    const matched = resolveImpactImportTargets(from, imp.to)
+      .find((candidate) => changedFileSet.has(normalizeImpactPath(candidate)));
+    if (matched) {
+      importers.push(from);
+      dependencies.push(matched);
+    }
+  }
+
+  const candidateFiles = uniqueImpact([
+    ...normalizedChangedFiles,
+    ...importers,
+    ...callers.map((item) => item.filePath),
+    ...mirrorCounterparts.map((item) => item.filePath),
+  ]);
+  const relatedTests = inferRelatedTestsFromArtifacts({
+    candidateFiles,
+    analogsMap: relatedArtifacts.analogsMap,
+    relationsMap: relatedArtifacts.relationsMap,
+    limit: budget.maxTests,
+  }).map((entry) => entry.filePath);
+  const recommendedTestFiles = uniqueImpact([
+    ...relatedTests,
+    ...risk.riskLabels.flatMap((label) => IMPACT_RISK_TEST_RECOMMENDATIONS[label] ?? []),
+  ]);
+
+  return {
+    changedFiles: normalizedChangedFiles,
+    changedSymbols: normalizedChangedSymbols,
+    riskLabels: risk.riskLabels,
+    requiresImpactCheck: risk.requiresImpactCheck,
+    callees: uniqueImpact(callees.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallees),
+    callers: uniqueImpact(callers.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallers),
+    importers: uniqueImpact(importers).slice(0, budget.maxImporters),
+    dependencies: uniqueImpact(dependencies).slice(0, budget.maxImporters),
+    mirrorCounterparts,
+    relatedTests,
+    recommendedTestFiles,
+    explanations: {
+      callees: changedRecords.map((record) => `${record.filePath}:${record.symbol}`),
+      callers: callers.map((entry) => `${entry.filePath}:${entry.symbol}`),
+      importers,
+      relatedTests,
+      mirrorCounterparts: mirrorCounterparts.map((entry) => `${entry.source} -> ${entry.filePath}`),
+    },
+  };
+}
+
+export function formatImpactConfidenceSummary(impact = {}) {
+  const lines = ['Impact checked:'];
+  if ((impact.changedFiles ?? []).length > 0) lines.push(`- Changed: ${(impact.changedFiles ?? []).slice(0, 3).join(', ')}`);
+  if ((impact.changedSymbols ?? []).length > 0) lines.push(`- Symbols: ${(impact.changedSymbols ?? []).slice(0, 5).join(', ')}`);
+  if ((impact.riskLabels ?? []).length > 0) lines.push(`- Risk: ${(impact.riskLabels ?? []).join(', ')}`);
+
+  const calleeSymbols = (impact.callees ?? []).map((item) => item?.symbol).filter(Boolean).slice(0, 5);
+  if (calleeSymbols.length > 0) lines.push(`- Callees: ${calleeSymbols.join(', ')}`);
+
+  const callerFiles = (impact.callers ?? []).map((item) => item?.filePath).filter(Boolean).slice(0, 5);
+  if (callerFiles.length > 0) lines.push(`- Callers: ${callerFiles.join(', ')}`);
+
+  const importers = (impact.importers ?? []).slice(0, 5);
+  if (importers.length > 0) lines.push(`- Importers: ${importers.join(', ')}`);
+
+  const mirrors = (impact.mirrorCounterparts ?? []).map((item) => item?.filePath).filter(Boolean).slice(0, 3);
+  if (mirrors.length > 0) lines.push(`- Mirrors: ${mirrors.join(', ')}`);
+
+  const relatedTests = (impact.relatedTests ?? []).slice(0, 4);
+  if (relatedTests.length > 0) lines.push(`- Related tests: ${relatedTests.join(', ')}`);
+
+  const recommendedTests = (impact.recommendedTestFiles ?? []).slice(0, 4);
+  if (recommendedTests.length > 0) lines.push(`- Recommended tests: ${recommendedTests.join(', ')}`);
+
+  return lines.join('\n');
+}
+
 function parseArtifactGeneratedAt(artifact) {
   const generatedAtRaw = String(artifact?.generatedAt ?? '').trim();
 

package/templates/.claude/ukit/index/route-catalog.mjs

@@ -223,8 +223,30 @@ export const ROUTE_CATALOG = [
     path: '.claude/skills/docs-quality/SKILL.md',
     order: 12,
     signals: [
-      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map)\b/i, score: 4 },
-      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map|status\.md)\b/i, score: 4 },
+      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|status\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+    ],
+  },
+  {
+    id: 'next-step',
+    path: '.claude/skills/next-step/SKILL.md',
+    order: 12.1,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(what(?:'s| is)? next|next steps?|project status|current status|where are we|continue(?: from)?(?: last session)?|roadmap|status\.md)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(làm gì tiếp|bước tiếp theo|tiếp theo làm gì|làm tiếp|đang ở đâu|trạng thái project|tình trạng project)\b/i, score: 7 },
+    ],
+  },
+  {
+    id: 'update-status',
+    path: '.claude/skills/update-status/SKILL.md',
+    order: 12.2,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(update|refresh|write|sync|record|capture|summari[sz]e).{0,48}\b(status\.md|project status|current state|next candidates?|session state)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(status\.md|project status).{0,48}\b(update|refresh|write|sync|record|capture|summari[sz]e)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(wrap up|handoff|end(?:ing)? this session|session summary|before final)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,48}\b(status|trạng thái|việc tiếp theo)\b/i, score: 9 },
     ],
   },
   {