@vpxa/kb 0.1.1

package/packages/tools/dist/forge-classify.d.ts

@@ -0,0 +1,44 @@
+/**
+ * kb_forge_classify — Automated FORGE tier classification.
+ *
+ * Determines Floor/Standard/Critical tier from file analysis.
+ * Uses path patterns, export scanning, and structural heuristics.
+ * No LLM needed.
+ */
+import type { ForgeTier } from './evidence-map.js';
+export interface ForgeClassifyOptions {
+    /** Files being modified (absolute or relative paths) */
+    files: string[];
+    /** Task description for keyword detection */
+    task: string;
+    /** Root path for package boundary detection */
+    rootPath: string;
+}
+export interface ClassifyTrigger {
+    rule: string;
+    detail: string;
+    source: 'blast_radius' | 'cross_package' | 'schema_contract' | 'security_auth' | 'task_hint' | 'default';
+}
+export interface TypedUnknownSeed {
+    description: string;
+    type: 'contract' | 'convention' | 'freshness' | 'runtime' | 'data-flow' | 'impact';
+    suggestedTool: string;
+}
+export interface ForgeClassifyCeremony {
+    ground: string;
+    build: string;
+    break: string;
+    evidenceMap: string;
+    gate: string;
+}
+export interface ForgeClassifyResult {
+    tier: ForgeTier;
+    triggers: ClassifyTrigger[];
+    packagesCrossed: string[];
+    hasSchemaChange: boolean;
+    hasSecurityPath: boolean;
+    typedUnknownSeeds: TypedUnknownSeed[];
+    ceremony: ForgeClassifyCeremony;
+}
+export declare function forgeClassify(options: ForgeClassifyOptions): Promise<ForgeClassifyResult>;
+//# sourceMappingURL=forge-classify.d.ts.map

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

@@ -0,0 +1,319 @@
+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

package/packages/tools/dist/forge-ground.d.ts

@@ -0,0 +1,64 @@
+/**
+ * kb_forge_ground — FORGE Phase 1 (Ground) batch executor.
+ *
+ * Executes the complete Ground phase as a single tool call:
+ * tier classification → scope map → typed unknowns → constraint seed → file summaries.
+ */
+import type { IEmbedder } from '@kb/embeddings';
+import type { IKnowledgeStore } from '@kb/store';
+import { type ForgeTier } from './evidence-map.js';
+import { type ClassifyTrigger, type TypedUnknownSeed } from './forge-classify.js';
+import { type ScopeMapResult } from './scope-map.js';
+export interface ForgeGroundOptions {
+    /** Task description */
+    task: string;
+    /** Target files being modified (absolute paths) */
+    files: string[];
+    /** Root path of the codebase */
+    rootPath: string;
+    /** Max constraint entries to load (default: 3) */
+    maxConstraints?: number;
+    /** Force a specific tier (skip auto-classify) */
+    forceTier?: ForgeTier;
+    /** Task ID for evidence map creation (default: auto-generated from task) */
+    taskId?: string;
+}
+export interface ConstraintRef {
+    source: string;
+    snippet: string;
+    relevance: number;
+}
+export interface ForgeGroundResult {
+    /** Computed or forced tier */
+    tier: ForgeTier;
+    /** Classification triggers (empty if tier was forced) */
+    classifyTriggers: ClassifyTrigger[];
+    /** Scope map (relevant files with focus ranges) — null for Floor tier */
+    scopeMap: ScopeMapResult | null;
+    /** Typed Unknown Queue seeds */
+    typedUnknownSeeds: TypedUnknownSeed[];
+    /** Constraint seed — relevant KB entries from decisions/patterns */
+    constraints: ConstraintRef[];
+    /** File summaries for target files */
+    fileSummaries: Array<{
+        path: string;
+        exports: string[];
+        functions: string[];
+        lines: number;
+        error?: string;
+    }>;
+    /** Evidence map task ID (created if Standard or Critical) */
+    evidenceMapTaskId: string | null;
+    /** Total estimated tokens for this Ground output */
+    estimatedTokens: number;
+    /** Ceremony recommendations for this tier */
+    ceremony: {
+        ground: string;
+        build: string;
+        break: string;
+        evidenceMap: string;
+        gate: string;
+    };
+}
+export declare function forgeGround(embedder: IEmbedder, store: IKnowledgeStore, options: ForgeGroundOptions): Promise<ForgeGroundResult>;
+//# sourceMappingURL=forge-ground.d.ts.map

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

@@ -0,0 +1,184 @@
+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

package/packages/tools/dist/git-context.d.ts

@@ -0,0 +1,22 @@
+export interface GitContextOptions {
+    cwd?: string;
+    commitCount?: number;
+    includeDiff?: boolean;
+}
+export interface GitContextResult {
+    branch: string;
+    status: {
+        staged: string[];
+        modified: string[];
+        untracked: string[];
+    };
+    recentCommits: Array<{
+        hash: string;
+        message: string;
+        author: string;
+        date: string;
+    }>;
+    diff?: string;
+}
+export declare function gitContext(options?: GitContextOptions): Promise<GitContextResult>;
+//# sourceMappingURL=git-context.d.ts.map

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

@@ -0,0 +1,46 @@
+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