@vpxa/kb 0.1.1 → 0.1.3

package/packages/tools/dist/forge-classify.js

@@ -1,319 +1,2 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, extname, relative, resolve } from "node:path";
-import { fileSummary } from "./file-summary.js";
-const MAX_SCAN_BYTES = 1e5;
-const MAX_SCAN_LINES = 200;
-const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
-const EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  ".kb-data",
-  ".kb-state",
-  ".turbo",
-  ".yarn",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules"
-]);
-const SECURITY_PATH_PATTERN = /auth|token|permission|acl|encrypt|secret|credential|jwt|oauth|password/i;
-const SECURITY_CONTENT_PATTERN = /\b(hash|sign|verify|bcrypt|jwt|decrypt|secret|password)\b/i;
-const SECURITY_TASK_PATTERN = /auth|security|permission|encrypt|secret|credential/i;
-const SCHEMA_PATH_PATTERN = /types\.ts$|schema\.ts$|contract\.ts$|\.proto$|openapi|swagger|\.graphql$/i;
-const SHARED_PATH_PATTERN = /(?:^|\/)(events|contracts|shared)(?:\/|$)/i;
-const SCHEMA_CONTENT_PATTERN = /export\s+interface\b|export\s+type\b|export\s+const\s+\w*Schema\w*\s*=\s*z\./i;
-const SCHEMA_TASK_PATTERN = /schema|contract|migration|breaking.change|api.change/i;
-const TASK_CRITICAL_PATTERN = /migration|data.?model|multi.?service|breaking|backward.?compat/i;
-const CEREMONIES = {
-  floor: {
-    ground: "Parasitic \u2014 read target file only",
-    build: "Implement directly",
-    break: "Skip",
-    evidenceMap: "Not required",
-    gate: "Self-certify"
-  },
-  standard: {
-    ground: "Scope map + blast radius + constraint seed",
-    build: "TDD \u2014 test first, then implement",
-    break: "Error paths + edge cases",
-    evidenceMap: "3-8 critical-path entries",
-    gate: "YIELD/HOLD evaluation"
-  },
-  critical: {
-    ground: "Full scope map + blast radius + trace + patterns + constraint pack",
-    build: "TDD + contract verification + cross-service validation",
-    break: "Error paths + edge cases + security dimensions + data-flow verification",
-    evidenceMap: "Comprehensive \u2014 all critical-path claims with receipts",
-    gate: "Strict YIELD/HOLD/HARD_BLOCK evaluation"
-  }
-};
-async function forgeClassify(options) {
-  const rootPath = resolve(options.rootPath);
-  const task = options.task.trim();
-  const files = options.files.map((filePath) => resolve(rootPath, filePath));
-  const triggers = [];
-  let hasSecurityPath = false;
-  let hasSchemaChange = false;
-  for (const filePath of files) {
-    const normalizedPath = normalizeForMatch(filePath, rootPath);
-    const scanText = readScanText(filePath);
-    if (SECURITY_PATH_PATTERN.test(normalizedPath) || SECURITY_CONTENT_PATTERN.test(scanText) || SECURITY_TASK_PATTERN.test(task)) {
-      hasSecurityPath = true;
-    }
-    if (SCHEMA_PATH_PATTERN.test(normalizedPath) || SHARED_PATH_PATTERN.test(normalizedPath) || SCHEMA_TASK_PATTERN.test(task) || SCHEMA_CONTENT_PATTERN.test(scanText) || await hasExportedContractShape(filePath)) {
-      hasSchemaChange = true;
-    }
-  }
-  if (hasSecurityPath) {
-    addTrigger(triggers, {
-      rule: "security-path",
-      detail: "Security/auth path, task, or content matched security heuristics",
-      source: "security_auth"
-    });
-  }
-  if (hasSchemaChange) {
-    addTrigger(triggers, {
-      rule: "schema-contract",
-      detail: "Schema or contract path, task, or export shape matched contract heuristics",
-      source: "schema_contract"
-    });
-  }
-  const blastRadius = countDirectImportBlastRadius(files, rootPath);
-  if (blastRadius.affectedFiles > 5) {
-    addTrigger(triggers, {
-      rule: "blast-radius-importers",
-      detail: `${blastRadius.affectedFiles} affected files via direct import scanning`,
-      source: "blast_radius"
-    });
-  }
-  const packagesCrossed = [
-    ...new Set(
-      files.map((filePath) => findPackageName(filePath, rootPath)).filter((packageName) => Boolean(packageName))
-    )
-  ].sort();
-  if (packagesCrossed.length >= 2) {
-    addTrigger(triggers, {
-      rule: "cross-package-boundary",
-      detail: `Files span ${packagesCrossed.length} packages: ${packagesCrossed.join(", ")}`,
-      source: "cross_package"
-    });
-  }
-  if (TASK_CRITICAL_PATTERN.test(task)) {
-    addTrigger(triggers, {
-      rule: "task-hint-critical",
-      detail: "Task description matched migration or compatibility criticality hints",
-      source: "task_hint"
-    });
-  }
-  const tier = triggers.length > 0 ? "critical" : files.length === 1 ? "floor" : "standard";
-  return {
-    tier,
-    triggers,
-    packagesCrossed,
-    hasSchemaChange,
-    hasSecurityPath,
-    typedUnknownSeeds: buildTypedUnknownSeeds(triggers),
-    ceremony: CEREMONIES[tier]
-  };
-}
-function addTrigger(triggers, trigger) {
-  if (triggers.some(
-    (existing) => existing.rule === trigger.rule && existing.source === trigger.source
-  )) {
-    return;
-  }
-  triggers.push(trigger);
-}
-function normalizeForMatch(filePath, rootPath) {
-  const absolutePath = resolve(rootPath, filePath);
-  const displayPath = relative(rootPath, absolutePath);
-  const safePath = displayPath && !displayPath.startsWith("..") ? displayPath : absolutePath;
-  return safePath.replace(/\\/g, "/");
-}
-function canScanFile(filePath) {
-  if (!existsSync(filePath)) {
-    return false;
-  }
-  try {
-    return statSync(filePath).size <= MAX_SCAN_BYTES;
-  } catch {
-    return false;
-  }
-}
-function readScanText(filePath) {
-  if (!canScanFile(filePath)) {
-    return "";
-  }
-  try {
-    return readFileSync(filePath, "utf-8").split(/\r?\n/).slice(0, MAX_SCAN_LINES).join("\n");
-  } catch {
-    return "";
-  }
-}
-async function hasExportedContractShape(filePath) {
-  if (!canScanFile(filePath)) {
-    return false;
-  }
-  try {
-    const summary = await fileSummary({ path: filePath });
-    const exportedNames = new Set(summary.exports);
-    return summary.interfaces.some((entry) => exportedNames.has(entry.name)) || summary.types.some((entry) => exportedNames.has(entry.name));
-  } catch {
-    return false;
-  }
-}
-function countDirectImportBlastRadius(targetFiles, rootPath) {
-  const existingTargets = new Set(targetFiles.filter((filePath) => existsSync(filePath)));
-  if (existingTargets.size === 0) {
-    return { affectedFiles: targetFiles.length, importers: [] };
-  }
-  const importers = /* @__PURE__ */ new Set();
-  for (const candidateFile of collectSourceFiles(rootPath)) {
-    if (existingTargets.has(candidateFile) || !canScanFile(candidateFile)) {
-      continue;
-    }
-    const scanText = readScanText(candidateFile);
-    if (!scanText) {
-      continue;
-    }
-    const specifiers = extractImportSpecifiers(scanText);
-    if (specifiers.some((specifier) => resolvesToTarget(specifier, candidateFile, existingTargets))) {
-      importers.add(candidateFile);
-    }
-  }
-  return {
-    affectedFiles: targetFiles.length + importers.size,
-    importers: [...importers].map((filePath) => relative(rootPath, filePath).replace(/\\/g, "/"))
-  };
-}
-function collectSourceFiles(rootPath) {
-  const files = [];
-  function walk(currentPath) {
-    let entries = [];
-    try {
-      entries = readdirSync(currentPath);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (EXCLUDED_DIRECTORIES.has(entry)) {
-        continue;
-      }
-      const fullPath = resolve(currentPath, entry);
-      let entryStat;
-      try {
-        entryStat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-      if (entryStat.isDirectory()) {
-        walk(fullPath);
-        continue;
-      }
-      if (SOURCE_EXTENSIONS.has(extname(entry).toLowerCase())) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(rootPath);
-  return files;
-}
-function extractImportSpecifiers(content) {
-  const specifiers = /* @__PURE__ */ new Set();
-  const pattern = /(?:from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\))/g;
-  for (const match of content.matchAll(pattern)) {
-    const specifier = match[1] ?? match[2] ?? match[3];
-    if (specifier) {
-      specifiers.add(specifier);
-    }
-  }
-  return [...specifiers];
-}
-function resolvesToTarget(specifier, importerFile, targets) {
-  if (!specifier.startsWith(".")) {
-    return false;
-  }
-  const basePath = resolve(dirname(importerFile), specifier);
-  const candidates = [
-    basePath,
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    `${basePath}.js`,
-    `${basePath}.jsx`,
-    `${basePath}.mts`,
-    `${basePath}.cts`,
-    `${basePath}.mjs`,
-    `${basePath}.cjs`,
-    resolve(basePath, "index.ts"),
-    resolve(basePath, "index.tsx"),
-    resolve(basePath, "index.js"),
-    resolve(basePath, "index.jsx")
-  ];
-  return candidates.some((candidate) => targets.has(candidate));
-}
-function buildTypedUnknownSeeds(triggers) {
-  return triggers.map((trigger) => {
-    switch (trigger.source) {
-      case "security_auth":
-        return {
-          description: "Verify auth and security assumptions before yielding",
-          type: "contract",
-          suggestedTool: "kb_search"
-        };
-      case "schema_contract":
-        return {
-          description: "Confirm schema and contract compatibility",
-          type: "contract",
-          suggestedTool: "kb_schema_validate"
-        };
-      case "blast_radius":
-        return {
-          description: "Inspect affected importers before delivery",
-          type: "impact",
-          suggestedTool: "kb_blast_radius"
-        };
-      case "cross_package":
-        return {
-          description: "Assess downstream package impact across boundaries",
-          type: "impact",
-          suggestedTool: "kb_blast_radius"
-        };
-      case "task_hint":
-        return {
-          description: "Check established conventions for migrations or compatibility work",
-          type: "convention",
-          suggestedTool: "kb_find_examples"
-        };
-      default:
-        return {
-          description: "No explicit unknown routing required",
-          type: "freshness",
-          suggestedTool: "kb_lookup"
-        };
-    }
-  });
-}
-function findPackageName(filePath, rootPath) {
-  let dir = dirname(resolve(rootPath, filePath));
-  const root = resolve(rootPath);
-  while (dir.length >= root.length) {
-    const packageJsonPath = resolve(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-        return pkg.name ?? relative(root, dir).replace(/\\/g, "/");
-      } catch {
-        return relative(root, dir).replace(/\\/g, "/");
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return void 0;
-}
-export {
-  forgeClassify
-};
-//# sourceMappingURL=forge-classify.js.map
+import{existsSync as g,readdirSync as _,readFileSync as S,statSync as k}from"node:fs";import{dirname as m,extname as C,relative as p,resolve as a}from"node:path";import{fileSummary as w}from"./file-summary.js";const E=1e5,x=200,v=new Set([".ts",".tsx",".js",".jsx",".mts",".cts",".mjs",".cjs"]),A=new Set([".git",".kb-data",".kb-state",".turbo",".yarn","build","coverage","dist","node_modules"]),N=/auth|token|permission|acl|encrypt|secret|credential|jwt|oauth|password/i,R=/\b(hash|sign|verify|bcrypt|jwt|decrypt|secret|password)\b/i,P=/auth|security|permission|encrypt|secret|credential/i,F=/types\.ts$|schema\.ts$|contract\.ts$|\.proto$|openapi|swagger|\.graphql$/i,U=/(?:^|\/)(events|contracts|shared)(?:\/|$)/i,$=/export\s+interface\b|export\s+type\b|export\s+const\s+\w*Schema\w*\s*=\s*z\./i,j=/schema|contract|migration|breaking.change|api.change/i,I=/migration|data.?model|multi.?service|breaking|backward.?compat/i,D={floor:{ground:"Parasitic \u2014 read target file only",build:"Implement directly",break:"Skip",evidenceMap:"Not required",gate:"Self-certify"},standard:{ground:"Scope map + blast radius + constraint seed",build:"TDD \u2014 test first, then implement",break:"Error paths + edge cases",evidenceMap:"3-8 critical-path entries",gate:"YIELD/HOLD evaluation"},critical:{ground:"Full scope map + blast radius + trace + patterns + constraint pack",build:"TDD + contract verification + cross-service validation",break:"Error paths + edge cases + security dimensions + data-flow verification",evidenceMap:"Comprehensive \u2014 all critical-path claims with receipts",gate:"Strict YIELD/HOLD/HARD_BLOCK evaluation"}};async function W(t){const s=a(t.rootPath),r=t.task.trim(),e=t.files.map(c=>a(s,c)),n=[];let i=!1,o=!1;for(const c of e){const f=O(c,s),T=b(c);(N.test(f)||R.test(T)||P.test(r))&&(i=!0),(F.test(f)||U.test(f)||j.test(r)||$.test(T)||await M(c))&&(o=!0)}i&&l(n,{rule:"security-path",detail:"Security/auth path, task, or content matched security heuristics",source:"security_auth"}),o&&l(n,{rule:"schema-contract",detail:"Schema or contract path, task, or export shape matched contract heuristics",source:"schema_contract"});const d=H(e,s);d.affectedFiles>5&&l(n,{rule:"blast-radius-importers",detail:`${d.affectedFiles} affected files via direct import scanning`,source:"blast_radius"});const u=[...new Set(e.map(c=>B(c,s)).filter(c=>!!c))].sort();u.length>=2&&l(n,{rule:"cross-package-boundary",detail:`Files span ${u.length} packages: ${u.join(", ")}`,source:"cross_package"}),I.test(r)&&l(n,{rule:"task-hint-critical",detail:"Task description matched migration or compatibility criticality hints",source:"task_hint"});const y=n.length>0?"critical":e.length===1?"floor":"standard";return{tier:y,triggers:n,packagesCrossed:u,hasSchemaChange:o,hasSecurityPath:i,typedUnknownSeeds:q(n),ceremony:D[y]}}function l(t,s){t.some(r=>r.rule===s.rule&&r.source===s.source)||t.push(s)}function O(t,s){const r=a(s,t),e=p(s,r);return(e&&!e.startsWith("..")?e:r).replace(/\\/g,"/")}function h(t){if(!g(t))return!1;try{return k(t).size<=E}catch{return!1}}function b(t){if(!h(t))return"";try{return S(t,"utf-8").split(/\r?\n/).slice(0,x).join(`
+`)}catch{return""}}async function M(t){if(!h(t))return!1;try{const s=await w({path:t}),r=new Set(s.exports);return s.interfaces.some(e=>r.has(e.name))||s.types.some(e=>r.has(e.name))}catch{return!1}}function H(t,s){const r=new Set(t.filter(n=>g(n)));if(r.size===0)return{affectedFiles:t.length,importers:[]};const e=new Set;for(const n of L(s)){if(r.has(n)||!h(n))continue;const i=b(n);if(!i)continue;z(i).some(d=>Y(d,n,r))&&e.add(n)}return{affectedFiles:t.length+e.size,importers:[...e].map(n=>p(s,n).replace(/\\/g,"/"))}}function L(t){const s=[];function r(e){let n=[];try{n=_(e)}catch{return}for(const i of n){if(A.has(i))continue;const o=a(e,i);let d;try{d=k(o)}catch{continue}if(d.isDirectory()){r(o);continue}v.has(C(i).toLowerCase())&&s.push(o)}}return r(t),s}function z(t){const s=new Set,r=/(?:from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\))/g;for(const e of t.matchAll(r)){const n=e[1]??e[2]??e[3];n&&s.add(n)}return[...s]}function Y(t,s,r){if(!t.startsWith("."))return!1;const e=a(m(s),t);return[e,`${e}.ts`,`${e}.tsx`,`${e}.js`,`${e}.jsx`,`${e}.mts`,`${e}.cts`,`${e}.mjs`,`${e}.cjs`,a(e,"index.ts"),a(e,"index.tsx"),a(e,"index.js"),a(e,"index.jsx")].some(i=>r.has(i))}function q(t){return t.map(s=>{switch(s.source){case"security_auth":return{description:"Verify auth and security assumptions before yielding",type:"contract",suggestedTool:"kb_search"};case"schema_contract":return{description:"Confirm schema and contract compatibility",type:"contract",suggestedTool:"kb_schema_validate"};case"blast_radius":return{description:"Inspect affected importers before delivery",type:"impact",suggestedTool:"kb_blast_radius"};case"cross_package":return{description:"Assess downstream package impact across boundaries",type:"impact",suggestedTool:"kb_blast_radius"};case"task_hint":return{description:"Check established conventions for migrations or compatibility work",type:"convention",suggestedTool:"kb_find_examples"};default:return{description:"No explicit unknown routing required",type:"freshness",suggestedTool:"kb_lookup"}}})}function B(t,s){let r=m(a(s,t));const e=a(s);for(;r.length>=e.length;){const n=a(r,"package.json");if(g(n))try{return JSON.parse(S(n,"utf-8")).name??p(e,r).replace(/\\/g,"/")}catch{return p(e,r).replace(/\\/g,"/")}const i=m(r);if(i===r)break;r=i}}export{W as forgeClassify};

package/packages/tools/dist/forge-ground.js

@@ -1,184 +1 @@
-import { evidenceMap } from "./evidence-map.js";
-import { fileSummary } from "./file-summary.js";
-import { forgeClassify } from "./forge-classify.js";
-import { scopeMap } from "./scope-map.js";
-import { estimateTokens } from "./text-utils.js";
-const DEFAULT_MAX_CONSTRAINTS = 3;
-const CONSTRAINT_SNIPPET_CHARS = 200;
-const CEREMONY_BY_TIER = {
-  floor: {
-    ground: "Parasitic \u2014 read target file only",
-    build: "Implement directly",
-    break: "Skip",
-    evidenceMap: "Not required",
-    gate: "Self-certify"
-  },
-  standard: {
-    ground: "Scope map + blast radius + constraint seed",
-    build: "TDD \u2014 test first, then implement",
-    break: "Error paths + edge cases",
-    evidenceMap: "3-8 critical-path entries",
-    gate: "YIELD/HOLD evaluation"
-  },
-  critical: {
-    ground: "Full scope map + blast radius + trace + patterns + constraint pack",
-    build: "TDD + contract verification + cross-service validation",
-    break: "Error paths + edge cases + security dimensions + data-flow verification",
-    evidenceMap: "Comprehensive \u2014 all critical-path claims with receipts",
-    gate: "Strict YIELD/HOLD/HARD_BLOCK evaluation"
-  }
-};
-async function forgeGround(embedder, store, options) {
-  const maxConstraints = options.maxConstraints ?? DEFAULT_MAX_CONSTRAINTS;
-  const classifyResult = await classifyTier(options);
-  const fileSummaries = await summarizeFiles(options.files);
-  if (classifyResult.tier === "floor") {
-    return finalizeResult({
-      tier: classifyResult.tier,
-      classifyTriggers: classifyResult.classifyTriggers,
-      scopeMap: null,
-      typedUnknownSeeds: classifyResult.typedUnknownSeeds,
-      constraints: [],
-      fileSummaries,
-      evidenceMapTaskId: null,
-      ceremony: classifyResult.ceremony
-    });
-  }
-  const [scopeMapResult, constraints, evidenceMapTaskId] = await Promise.all([
-    loadScopeMap(embedder, store, options.task, classifyResult.tier),
-    loadConstraints(embedder, store, options.task, maxConstraints),
-    createEvidenceMap(
-      options.rootPath,
-      options.taskId ?? generateTaskId(options.task),
-      classifyResult.tier
-    )
-  ]);
-  return finalizeResult({
-    tier: classifyResult.tier,
-    classifyTriggers: classifyResult.classifyTriggers,
-    scopeMap: scopeMapResult,
-    typedUnknownSeeds: classifyResult.typedUnknownSeeds,
-    constraints,
-    fileSummaries,
-    evidenceMapTaskId,
-    ceremony: classifyResult.ceremony
-  });
-}
-async function classifyTier(options) {
-  if (options.forceTier) {
-    return {
-      tier: options.forceTier,
-      classifyTriggers: [],
-      typedUnknownSeeds: [],
-      ceremony: getCeremony(options.forceTier)
-    };
-  }
-  try {
-    const result = await forgeClassify({
-      files: options.files,
-      task: options.task,
-      rootPath: options.rootPath
-    });
-    return {
-      tier: result.tier,
-      classifyTriggers: result.triggers,
-      typedUnknownSeeds: result.typedUnknownSeeds,
-      ceremony: result.ceremony
-    };
-  } catch {
-    return {
-      tier: "standard",
-      classifyTriggers: [],
-      typedUnknownSeeds: [],
-      ceremony: getCeremony("standard")
-    };
-  }
-}
-async function loadScopeMap(embedder, store, task, tier) {
-  try {
-    return await scopeMap(embedder, store, {
-      task,
-      maxFiles: tier === "critical" ? 20 : 10
-    });
-  } catch {
-    return null;
-  }
-}
-async function loadConstraints(embedder, store, task, maxConstraints) {
-  try {
-    const query = `decision pattern convention ${task}`;
-    const vector = typeof embedder.embedQuery === "function" ? await embedder.embedQuery(query) : await embedder.embed(query);
-    const results = await store.search(vector, {
-      limit: maxConstraints,
-      origin: "curated"
-    });
-    return results.slice(0, maxConstraints).map((result) => toConstraintRef(result));
-  } catch {
-    return [];
-  }
-}
-async function summarizeFiles(files) {
-  return Promise.all(files.map(async (path) => summarizeFile(path)));
-}
-async function summarizeFile(path) {
-  try {
-    const summary = await fileSummary({ path });
-    return toGroundFileSummary(summary);
-  } catch (error) {
-    return {
-      path,
-      exports: [],
-      functions: [],
-      lines: 0,
-      error: error instanceof Error ? error.message : "Unable to summarize file"
-    };
-  }
-}
-async function createEvidenceMap(rootPath, taskId, tier) {
-  try {
-    evidenceMap({ action: "create", taskId, tier }, rootPath);
-    return taskId;
-  } catch {
-    return null;
-  }
-}
-function toConstraintRef(result) {
-  return {
-    source: result.record.sourcePath,
-    snippet: compactSnippet(result.record.content),
-    relevance: result.score
-  };
-}
-function compactSnippet(content) {
-  const singleLine = content.replace(/\s+/g, " ").trim();
-  if (singleLine.length <= CONSTRAINT_SNIPPET_CHARS) {
-    return singleLine;
-  }
-  return `${singleLine.slice(0, CONSTRAINT_SNIPPET_CHARS - 3).trimEnd()}...`;
-}
-function toGroundFileSummary(summary) {
-  return {
-    path: summary.path,
-    exports: summary.exports,
-    functions: summary.functions.map((fn) => fn.name),
-    lines: summary.lines
-  };
-}
-function getCeremony(tier) {
-  return { ...CEREMONY_BY_TIER[tier] };
-}
-function finalizeResult(result) {
-  return {
-    ...result,
-    estimatedTokens: estimateTokens(JSON.stringify(result))
-  };
-}
-function generateTaskId(task) {
-  const slug = task.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean).slice(0, 5).join("-");
-  const ts = Date.now().toString(36);
-  return `${slug || "task"}-${ts}`;
-}
-export {
-  forgeGround
-};
-//# sourceMappingURL=forge-ground.js.map
+import{evidenceMap as g}from"./evidence-map.js";import{fileSummary as m}from"./file-summary.js";import{forgeClassify as p}from"./forge-classify.js";import{scopeMap as f}from"./scope-map.js";import{estimateTokens as y}from"./text-utils.js";const S=3,c=200,T={floor:{ground:"Parasitic \u2014 read target file only",build:"Implement directly",break:"Skip",evidenceMap:"Not required",gate:"Self-certify"},standard:{ground:"Scope map + blast radius + constraint seed",build:"TDD \u2014 test first, then implement",break:"Error paths + edge cases",evidenceMap:"3-8 critical-path entries",gate:"YIELD/HOLD evaluation"},critical:{ground:"Full scope map + blast radius + trace + patterns + constraint pack",build:"TDD + contract verification + cross-service validation",break:"Error paths + edge cases + security dimensions + data-flow verification",evidenceMap:"Comprehensive \u2014 all critical-path claims with receipts",gate:"Strict YIELD/HOLD/HARD_BLOCK evaluation"}};async function D(e,r,t){const i=t.maxConstraints??S,n=await k(t),s=await F(t.files);if(n.tier==="floor")return u({tier:n.tier,classifyTriggers:n.classifyTriggers,scopeMap:null,typedUnknownSeeds:n.typedUnknownSeeds,constraints:[],fileSummaries:s,evidenceMapTaskId:null,ceremony:n.ceremony});const[a,o,d]=await Promise.all([R(e,r,t.task,n.tier),w(e,r,t.task,i),h(t.rootPath,t.taskId??C(t.task),n.tier)]);return u({tier:n.tier,classifyTriggers:n.classifyTriggers,scopeMap:a,typedUnknownSeeds:n.typedUnknownSeeds,constraints:o,fileSummaries:s,evidenceMapTaskId:d,ceremony:n.ceremony})}async function k(e){if(e.forceTier)return{tier:e.forceTier,classifyTriggers:[],typedUnknownSeeds:[],ceremony:l(e.forceTier)};try{const r=await p({files:e.files,task:e.task,rootPath:e.rootPath});return{tier:r.tier,classifyTriggers:r.triggers,typedUnknownSeeds:r.typedUnknownSeeds,ceremony:r.ceremony}}catch{return{tier:"standard",classifyTriggers:[],typedUnknownSeeds:[],ceremony:l("standard")}}}async function R(e,r,t,i){try{return await f(e,r,{task:t,maxFiles:i==="critical"?20:10})}catch{return null}}async function w(e,r,t,i){try{const n=`decision pattern convention ${t}`,s=typeof e.embedQuery=="function"?await e.embedQuery(n):await e.embed(n);return(await r.search(s,{limit:i,origin:"curated"})).slice(0,i).map(o=>v(o))}catch{return[]}}async function F(e){return Promise.all(e.map(async r=>b(r)))}async function b(e){try{const r=await m({path:e});return M(r)}catch(r){return{path:e,exports:[],functions:[],lines:0,error:r instanceof Error?r.message:"Unable to summarize file"}}}async function h(e,r,t){try{return g({action:"create",taskId:r,tier:t},e),r}catch{return null}}function v(e){return{source:e.record.sourcePath,snippet:I(e.record.content),relevance:e.score}}function I(e){const r=e.replace(/\s+/g," ").trim();return r.length<=c?r:`${r.slice(0,c-3).trimEnd()}...`}function M(e){return{path:e.path,exports:e.exports,functions:e.functions.map(r=>r.name),lines:e.lines}}function l(e){return{...T[e]}}function u(e){return{...e,estimatedTokens:y(JSON.stringify(e))}}function C(e){const r=e.toLowerCase().replace(/[^a-z0-9\s]/g," ").split(/\s+/).filter(Boolean).slice(0,5).join("-"),t=Date.now().toString(36);return`${r||"task"}-${t}`}export{D as forgeGround};

package/packages/tools/dist/git-context.js

@@ -1,46 +1,3 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-async function git(args, cwd) {
-  try {
-    const { stdout } = await execFileAsync("git", args, { cwd });
-    return stdout.toString().trim();
-  } catch {
-    return "";
-  }
-}
-async function gitContext(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const commitCount = options.commitCount ?? 5;
-  const [branchRaw, statusRaw, logRaw, diffRaw] = await Promise.all([
-    git(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
-    git(["status", "--porcelain"], cwd),
-    git(["log", `--max-count=${commitCount}`, "--format=%h|%s|%an|%ai"], cwd),
-    options.includeDiff ? git(["diff", "--stat", "--no-color"], cwd) : Promise.resolve("")
-  ]);
-  const staged = [];
-  const modified = [];
-  const untracked = [];
-  for (const line of statusRaw.split("\n").filter(Boolean)) {
-    const x = line[0];
-    const y = line[1];
-    const file = line.slice(3).trim();
-    if (x !== " " && x !== "?") staged.push(file);
-    if (y === "M" || y === "D") modified.push(file);
-    if (x === "?") untracked.push(file);
-  }
-  const recentCommits = logRaw.split("\n").filter(Boolean).map((line) => {
-    const [hash, message, author, date] = line.split("|");
-    return { hash, message, author, date };
-  });
-  return {
-    branch: branchRaw || "unknown",
-    status: { staged, modified, untracked },
-    recentCommits,
-    diff: diffRaw || void 0
-  };
-}
-export {
-  gitContext
-};
-//# sourceMappingURL=git-context.js.map
+import{execFile as x}from"node:child_process";import{promisify as w}from"node:util";const C=w(x);async function o(n,t){try{const{stdout:a}=await C("git",n,{cwd:t});return a.toString().trim()}catch{return""}}async function R(n={}){const t=n.cwd??process.cwd(),a=n.commitCount??5,[u,g,l,d]=await Promise.all([o(["rev-parse","--abbrev-ref","HEAD"],t),o(["status","--porcelain"],t),o(["log",`--max-count=${a}`,"--format=%h|%s|%an|%ai"],t),n.includeDiff?o(["diff","--stat","--no-color"],t):Promise.resolve("")]),c=[],f=[],m=[];for(const i of g.split(`
+`).filter(Boolean)){const s=i[0],e=i[1],r=i.slice(3).trim();s!==" "&&s!=="?"&&c.push(r),(e==="M"||e==="D")&&f.push(r),s==="?"&&m.push(r)}const p=l.split(`
+`).filter(Boolean).map(i=>{const[s,e,r,h]=i.split("|");return{hash:s,message:e,author:r,date:h}});return{branch:u||"unknown",status:{staged:c,modified:f,untracked:m},recentCommits:p,diff:d||void 0}}export{R as gitContext};