@kodevibe/harness 0.11.0 → 0.11.2

package/harness/skills/wrap-up.md

@@ -138,6 +138,15 @@ For each issue/error that occurred in this session:
 
 > **Self-check**: `docs/dependency-map.md`에 이 세션에서 새로 추가한 모듈이 모두 등록되었는지 확인. 누락 시 즉시 추가. state-check가 PASS 또는 WARN을 반환해야 다음 단계로 진행합니다.
 
+### Step 5.55: Refresh Project Docs Hub Index (if applicable)
+
+Run only if user used/requested `docs-bridge`, or Project Docs Hub Index has real rows.
+
+1. For changed docs (`README*`, `docs/`, ADR/design/runbook/API specs), refresh indexed review/status.
+2. For new docs, add `proposed` rows or recommend `docs-bridge`.
+3. Never write external hubs, invent targets, change visibility, or convert `local-only` / `pending` without explicit request.
+4. Keep filesystem paths, vault names, page IDs, and resolver details out of tracked state; use `.harness/docs-bridge.local.*`.
+
 ### Step 5.6: Resolve STATE-AUDIT Flags (if applicable)
 
 If the `reviewer` agent was run in this session and produced `[STATE-AUDIT]` flags:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodevibe/harness",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "kode:harness — harness engineering for keeping every developer's AI aligned on one project direction.",
   "keywords": [
     "llm",
@@ -46,8 +46,17 @@
   },
   "scripts": {
     "test": "node --test tests/*.test.js",
+    "harness:check-pack": "node scripts/check-public-pack.js",
     "harness:check-drift": "node scripts/check-harness-drift.js",
-    "harness:sync": "node bin/cli.js init --ide vscode --batch --dir . --overwrite"
+    "harness:dependency-scan": "node scripts/check-dependency-map.js",
+    "harness:guard": "node scripts/harness-guard.js",
+    "harness:guard:all": "node scripts/harness-guard.js --all",
+    "harness:guard:wrap-up": "node scripts/harness-guard.js --wrap-up",
+    "harness:llm-bench": "node scripts/llm-bench.js",
+    "harness:llm-bench:export": "node scripts/llm-bench.js --export-prompts --scenarios docs/llm-bench-scenarios.json --out bench/r10",
+    "harness:llm-bench:smoke": "node scripts/llm-bench.js docs/llm-bench-results.example.json",
+    "harness:llm-bench:real": "node scripts/llm-bench.js docs/llm-bench-results.json --require-real",
+    "harness:state-sync": "node scripts/harness-guard.js --state-sync"
   },
   "publishConfig": {
     "access": "public"

package/src/dependency-scan.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const DEFAULT_ROOTS = ['src', 'app', 'lib', 'packages', 'services'];
+const SKIP_DIRS = new Set(['.git', '.harness', 'node_modules', 'dist', 'build', 'coverage', '.next', '.turbo']);
+
+function toPosix(file) {
+  return String(file || '').replace(/\\/g, '/');
+}
+
+function stripCodeComments(content) {
+  return String(content || '')
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|[^:])\/\/.*$/gm, '$1');
+}
+
+function isSourceFile(file) {
+  return SOURCE_EXTENSIONS.has(path.extname(file));
+}
+
+function walkSourceFiles(cwd, roots = DEFAULT_ROOTS) {
+  const files = [];
+
+  function walk(dir) {
+    if (!fs.existsSync(dir)) return;
+    for (const name of fs.readdirSync(dir)) {
+      if (SKIP_DIRS.has(name)) continue;
+      const full = path.join(dir, name);
+      const st = fs.statSync(full);
+      if (st.isDirectory()) walk(full);
+      else if (st.isFile() && isSourceFile(full)) files.push(toPosix(path.relative(cwd, full)));
+    }
+  }
+
+  for (const root of roots) walk(path.join(cwd, root));
+  return files.sort();
+}
+
+function moduleKeyForFile(file) {
+  const parts = toPosix(file).split('/').filter(Boolean);
+  if (parts.length === 0) return '';
+  if (parts[0] === 'packages' || parts[0] === 'services') {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0];
+  }
+  if (DEFAULT_ROOTS.includes(parts[0])) {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0];
+  }
+  return parts[0];
+}
+
+function extractLocalSpecifiers(content) {
+  const clean = stripCodeComments(content);
+  const specs = [];
+  const patterns = [
+    /\bimport\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
+    /\bexport\s+[^'"]+\s+from\s+['"]([^'"]+)['"]/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  ];
+  for (const re of patterns) {
+    for (const match of clean.matchAll(re)) {
+      const spec = match[1];
+      if (spec.startsWith('.')) specs.push(spec);
+    }
+  }
+  return specs;
+}
+
+function normalizeRelativeTarget(fromFile, specifier) {
+  const fromDir = path.posix.dirname(toPosix(fromFile));
+  return path.posix.normalize(path.posix.join(fromDir, specifier));
+}
+
+function scanDependencyGraph({ cwd = process.cwd(), files = null, roots = DEFAULT_ROOTS } = {}) {
+  const sourceFiles = files ? files.filter(isSourceFile).map(toPosix).sort() : walkSourceFiles(cwd, roots);
+  const modules = new Map();
+
+  for (const file of sourceFiles) {
+    const module = moduleKeyForFile(file);
+    if (!module) continue;
+    if (!modules.has(module)) modules.set(module, { module, files: new Set(), dependsOn: new Set() });
+    modules.get(module).files.add(file);
+
+    const abs = path.join(cwd, file);
+    if (!fs.existsSync(abs)) continue;
+    const content = fs.readFileSync(abs, 'utf8');
+    for (const spec of extractLocalSpecifiers(content)) {
+      const target = normalizeRelativeTarget(file, spec);
+      const dep = moduleKeyForFile(target);
+      if (dep && dep !== module) modules.get(module).dependsOn.add(dep);
+    }
+  }
+
+  return [...modules.values()]
+    .map((entry) => ({
+      module: entry.module,
+      files: [...entry.files].sort(),
+      dependsOn: [...entry.dependsOn].sort(),
+    }))
+    .sort((a, b) => a.module.localeCompare(b.module));
+}
+
+function markdownTableRows(section) {
+  const lines = String(section || '').split('\n').map((line) => line.trim()).filter((line) => line.startsWith('|'));
+  if (lines.length < 2) return [];
+  const headers = lines[0].replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
+  return lines.slice(2)
+    .filter((line) => !/^\|\s*[-:|\s]+\|?$/.test(line))
+    .map((line) => {
+      const cells = line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
+      const row = {};
+      headers.forEach((header, i) => { row[header] = cells[i] || ''; });
+      row.__raw = line;
+      return row;
+    });
+}
+
+function section(content, header) {
+  const re = new RegExp(`^##\\s+${header}\\s*$`, 'm');
+  const match = re.exec(content);
+  if (!match) return '';
+  const rest = content.slice(match.index + match[0].length);
+  const next = /^##\s+/m.exec(rest);
+  return next ? rest.slice(0, next.index) : rest;
+}
+
+function splitDepends(value) {
+  return String(value || '')
+    .replace(/`/g, '')
+    .split(/(?:<br\s*\/?>|[,;]|\s{2,})/i)
+    .map((item) => item.trim())
+    .filter((item) => item && !/^[-–—]$/.test(item) && !/^n\/a$/i.test(item) && !/^none$/i.test(item));
+}
+
+function parseDependencyMap(content) {
+  const body = section(content, 'Module Registry')
+    || section(content, 'Module Dependency Map')
+    || section(content, 'Module Map')
+    || content;
+  return markdownTableRows(body)
+    .map((row) => ({
+      module: row.Module || row.module || '',
+      dependsOn: splitDepends(row['Depends On'] || row.Depends || row.Dependencies || ''),
+      raw: row.__raw,
+    }))
+    .filter((row) => row.module);
+}
+
+function checkDependencyMapCoverage({ graph = [], dependencyMap = '' } = {}) {
+  const violations = [];
+  const rows = parseDependencyMap(dependencyMap);
+  const rowByModule = new Map(rows.map((row) => [row.module, row]));
+
+  for (const item of graph) {
+    const row = rowByModule.get(item.module);
+    if (!row) {
+      violations.push({
+        check: 'dependency-scan',
+        severity: 'error',
+        line: 0,
+        message: `Module ${item.module} exists in source files but is missing from dependency-map.md (R7 source dependency scan).`,
+      });
+      continue;
+    }
+    const mapped = row.dependsOn.join(' ');
+    for (const dep of item.dependsOn) {
+      if (!mapped.includes(dep)) {
+        violations.push({
+          check: 'dependency-scan',
+          severity: 'error',
+          line: 0,
+          message: `Module ${item.module} imports ${dep}, but dependency-map.md does not list it in Depends On (R7 source dependency scan).`,
+        });
+      }
+    }
+  }
+
+  return violations;
+}
+
+module.exports = {
+  DEFAULT_ROOTS,
+  isSourceFile,
+  walkSourceFiles,
+  moduleKeyForFile,
+  extractLocalSpecifiers,
+  normalizeRelativeTarget,
+  scanDependencyGraph,
+  parseDependencyMap,
+  checkDependencyMapCoverage,
+};