@fenglimg/fabric-cli 1.8.0-rc.3 → 2.0.0-rc.1

package/dist/chunk-UHNP7T7W.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+import {
+  createDebugLogger,
+  paint,
+  resolveDevMode,
+  symbol,
+  t
+} from "./chunk-5LOYBXWD.js";
+
+// src/commands/scan.ts
+import { createHash } from "crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { defineCommand } from "citty";
+import {
+  KnowledgeIdAllocator,
+  appendEventLedgerEvent,
+  writeRuleMeta
+} from "@fenglimg/fabric-server";
+import {
+  formatKnowledgeId
+} from "@fenglimg/fabric-shared";
+import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+
+// src/scanner/detector.ts
+import { detectFramework } from "@fenglimg/fabric-shared/node";
+
+// src/scanner/ignores.ts
+var DEFAULT_IGNORES = [
+  "**/*.meta",
+  "library/**",
+  "temp/**",
+  "build/**",
+  "settings/**",
+  "profiles/**",
+  "node_modules/**",
+  "dist/**",
+  ".git/**",
+  ".fabric/**"
+];
+function resolveIgnores(fabricConfig) {
+  return [...DEFAULT_IGNORES, ...fabricConfig?.scanIgnores ?? []];
+}
+
+// src/commands/scan.ts
+async function createScanReport(targetInput = process.cwd(), fabricConfig) {
+  const target = normalizeTarget(targetInput);
+  const framework = detectFramework(target);
+  const readmeQuality = getReadmeQuality(target);
+  const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
+  const hasExistingFabric = existsSync(join(target, ".fabric", "bootstrap", "README.md")) || existsSync(join(target, ".fabric"));
+  const walkResult = walkFiles(target, resolveIgnores(fabricConfig));
+  return {
+    target,
+    framework,
+    readmeQuality,
+    hasContributing,
+    fileCount: walkResult.fileCount,
+    ignoredCount: walkResult.ignoredCount,
+    hasExistingFabric,
+    recommendations: buildRecommendations({
+      framework,
+      readmeQuality,
+      hasContributing,
+      hasExistingFabric
+    })
+  };
+}
+var KNOWLEDGE_DIR = ".fabric/knowledge";
+var SCAN_STATE_FILE = ".scan-state.json";
+var FORENSIC_FILE = ".fabric/forensic.json";
+var AGENTS_META_FILE = ".fabric/agents.meta.json";
+var LAYER_REASON = "project artifact (deterministic init scan)";
+async function runInitScan(targetInput, options = {}) {
+  const startTs = Date.now();
+  const target = normalizeTarget(targetInput);
+  const forensicPath = join(target, FORENSIC_FILE);
+  if (!existsSync(forensicPath)) {
+    throw new Error(t("cli.scan.error.missing-forensic", { path: forensicPath }));
+  }
+  const forensic = await readForensic(forensicPath);
+  const nowIso = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const tags = deriveTagsFromForensic(forensic);
+  const candidates = [
+    buildTechStackEntry(forensic, nowIso, tags),
+    buildModuleStructureEntry(forensic, nowIso, tags),
+    buildBuildConfigEntry(forensic, nowIso, tags),
+    buildCodeStyleEntry(forensic, nowIso, tags),
+    buildCIConfigEntry(forensic, nowIso, tags),
+    buildReadmeFirstParaEntry(target, forensic, nowIso, tags),
+    buildProjectBriefEntry(target, forensic, nowIso, tags)
+  ];
+  const entries = candidates.filter((e) => e !== null);
+  const sidecarPath = join(target, KNOWLEDGE_DIR, SCAN_STATE_FILE);
+  const sidecar = await readScanState(sidecarPath);
+  const allocator = new KnowledgeIdAllocator(join(target, AGENTS_META_FILE));
+  const written = [];
+  const skipped = [];
+  const placedEntries = [];
+  for (const entry of entries) {
+    const targetPath = join(target, KNOWLEDGE_DIR, entry.target_subdir, `${entry.slug}.md`);
+    const existingId = findExistingIdForFile(sidecar, targetPath, target);
+    const id = existingId ?? await allocator.allocate(entry.layer, entry.type);
+    const built = { ...entry, id };
+    placedEntries.push(built);
+    const fullContent = renderMarkdown(built);
+    const bodyHash = sha256(stripFrontmatter(fullContent));
+    const sidecarKey = id;
+    if (sidecar[sidecarKey] === bodyHash && existsSync(targetPath)) {
+      skipped.push(id);
+      continue;
+    }
+    await ensureParentDirectory(targetPath);
+    await atomicWriteText(targetPath, fullContent);
+    sidecar[sidecarKey] = bodyHash;
+    written.push(id);
+  }
+  await ensureParentDirectory(sidecarPath);
+  await atomicWriteJson(sidecarPath, sidecar);
+  await registerKnowledgeNodesInMeta(target, placedEntries);
+  await writeRuleMeta(target, { source: "doctor_fix" });
+  const durationMs = Date.now() - startTs;
+  await appendEventLedgerEvent(target, {
+    event_type: "init_scan_completed",
+    written_stable_ids: written,
+    duration_ms: durationMs,
+    source: options.source ?? "scan"
+  });
+  return {
+    written_stable_ids: written,
+    skipped_stable_ids: skipped,
+    total_entries: entries.length,
+    duration_ms: durationMs
+  };
+}
+var scanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: t("cli.scan.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.scan.args.target.description")
+    },
+    debug: {
+      type: "boolean",
+      description: t("cli.scan.args.debug.description"),
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: t("cli.scan.args.json.description"),
+      default: false
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const logger = createDebugLogger(args.debug);
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    logger(`scan target source: ${resolution.source}`);
+    for (const step of resolution.chain) {
+      logger(step);
+    }
+    try {
+      const result = await runInitScan(resolution.target, { source: "scan" });
+      if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      printPrettyResult(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`${symbol.warn} ${paint.warn(message)}`);
+      process.exitCode = 1;
+    }
+  }
+});
+var scan_default = scanCommand;
+function buildTechStackEntry(forensic, nowIso, tags) {
+  const framework = forensic.framework;
+  const byExt = forensic.topology.by_ext ?? {};
+  const topExtensions = Object.entries(byExt).sort(([, a], [, b]) => b - a).slice(0, 5).map(([ext, count]) => `${ext} (${count})`);
+  const evidenceLines = framework.evidence.length > 0 ? framework.evidence.slice(0, 6) : ["(no explicit framework evidence)"];
+  const body = renderSections({
+    mission: `Track the primary tech stack and runtime surface used by ${forensic.project_name}.`,
+    context: [
+      `Framework: ${framework.kind}${framework.version ? ` ${framework.version}` : ""}${framework.subkind ? ` / ${framework.subkind}` : ""}`,
+      `Top file extensions: ${topExtensions.length > 0 ? topExtensions.join(", ") : "(none)"}`,
+      `Evidence:`,
+      ...evidenceLines.map((line) => `- ${line}`)
+    ].join("\n")
+  });
+  return {
+    type: "model",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: `Tech stack: ${framework.kind}`,
+    body,
+    target_subdir: "models",
+    slug: "tech-stack",
+    tags
+  };
+}
+function buildModuleStructureEntry(forensic, nowIso, tags) {
+  const keyDirs = forensic.topology.key_dirs ?? [];
+  const entryPoints = forensic.entry_points ?? [];
+  const totalFiles = forensic.topology.total_files ?? 0;
+  const dirsBlock = keyDirs.length > 0 ? keyDirs.slice(0, 12).map((dir) => `- ${dir}`).join("\n") : "- (no key directories detected)";
+  const entriesBlock = entryPoints.length > 0 ? entryPoints.slice(0, 8).map((ep) => `- ${ep.path} \u2014 ${ep.reason}`).join("\n") : "- (no entry points detected)";
+  const body = renderSections({
+    mission: `Map the high-level module layout and primary entry points of ${forensic.project_name}.`,
+    context: [
+      `Total files: ${totalFiles}`,
+      `Max directory depth: ${forensic.topology.max_depth ?? 0}`,
+      "",
+      "Key directories:",
+      dirsBlock,
+      "",
+      "Entry points:",
+      entriesBlock
+    ].join("\n")
+  });
+  return {
+    type: "model",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "Module structure",
+    body,
+    target_subdir: "models",
+    slug: "module-structure",
+    tags
+  };
+}
+function buildBuildConfigEntry(forensic, nowIso, tags) {
+  const configFiles = (forensic.candidate_files ?? []).filter((entry) => entry.family === "config").map((entry) => entry.path);
+  const framework = forensic.framework.kind;
+  const configBlock = configFiles.length > 0 ? configFiles.map((file) => `- ${file}`).join("\n") : "- (no config files detected)";
+  const body = renderSections({
+    mission: `Document the deterministic build/bootstrap configuration anchoring ${forensic.project_name}.`,
+    businessLogic: [
+      `1. Detect framework: \`${framework}\`.`,
+      `2. Read configuration files in declared order.`,
+      `3. Honor compiler/bundler boundaries before generating new code.`,
+      `4. Treat config drift as a fact-check signal \u2014 re-run \`fab scan\` after edits.`
+    ].join("\n"),
+    context: [
+      `Framework: ${framework}`,
+      "",
+      "Configuration files:",
+      configBlock
+    ].join("\n")
+  });
+  return {
+    type: "process",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "Build configuration",
+    body,
+    target_subdir: "processes",
+    slug: "build-config",
+    tags
+  };
+}
+function buildCodeStyleEntry(forensic, nowIso, tags) {
+  const dominantPatterns = (forensic.assertions ?? []).filter((a) => a.type === "pattern" || a.type === "domain").slice(0, 4).map((a) => `- ${a.statement}`);
+  const proposedRules = (forensic.assertions ?? []).map((a) => a.proposed_rule).filter((rule) => typeof rule === "string" && rule.length > 0).slice(0, 4);
+  const patternsBlock = dominantPatterns.length > 0 ? dominantPatterns.join("\n") : "- (no dominant patterns detected)";
+  const rulesBlock = proposedRules.length > 0 ? proposedRules.map((rule) => `- ${rule}`).join("\n") : "- Follow existing module/file patterns; do not introduce new conventions without team agreement.";
+  const body = renderSections({
+    mission: `Codify the recurring authoring conventions observed in ${forensic.project_name}.`,
+    mandatoryInjection: [
+      "When generating or modifying source files in this repo, AI agents MUST:",
+      rulesBlock
+    ].join("\n"),
+    context: [
+      "Detected patterns:",
+      patternsBlock
+    ].join("\n")
+  });
+  return {
+    type: "guideline",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "Code style guidelines",
+    body,
+    target_subdir: "guidelines",
+    slug: "code-style",
+    tags
+  };
+}
+function buildCIConfigEntry(forensic, nowIso, tags) {
+  const ciFiles = (forensic.candidate_files ?? []).map((entry) => entry.path).filter((path) => isCIConfigPath(path));
+  const ciExtensions = forensic.topology.by_ext ?? {};
+  const hasCISignal = ciFiles.length > 0 || Object.keys(ciExtensions).some((ext) => ext === ".yml" || ext === ".yaml") && (forensic.assertions ?? []).some((a) => /ci|workflow|pipeline/i.test(a.statement));
+  if (!hasCISignal) {
+    return null;
+  }
+  const filesBlock = ciFiles.length > 0 ? ciFiles.map((file) => `- ${file}`).join("\n") : "- (CI configuration inferred from repository topology)";
+  const body = renderSections({
+    mission: `Document the CI / continuous-verification pipeline guarding ${forensic.project_name}.`,
+    businessLogic: [
+      "1. Pull request opens \u2192 CI workflow triggers.",
+      "2. Lint + typecheck + unit tests must pass before review.",
+      "3. Failing checks block merge until resolved.",
+      "4. Updates to CI configuration should accompany the change they enable."
+    ].join("\n"),
+    context: [
+      "CI configuration sources:",
+      filesBlock
+    ].join("\n")
+  });
+  return {
+    type: "process",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "CI configuration",
+    body,
+    target_subdir: "processes",
+    slug: "ci-config",
+    tags
+  };
+}
+function buildReadmeFirstParaEntry(target, forensic, nowIso, tags) {
+  if (forensic.readme.quality === "missing") {
+    return null;
+  }
+  const readmePath = join(target, "README.md");
+  if (!existsSync(readmePath)) {
+    return null;
+  }
+  const readme = readFileSync(readmePath, "utf8");
+  const firstPara = extractFirstParagraph(readme);
+  if (firstPara === null) {
+    return null;
+  }
+  const body = renderSections({
+    mission: `Preserve the README headline and first paragraph as the canonical project elevator pitch.`,
+    context: [
+      `Source: README.md (${forensic.readme.line_count} lines, quality=${forensic.readme.quality})`,
+      "",
+      "Excerpt:",
+      "> " + firstPara.split("\n").join("\n> ")
+    ].join("\n")
+  });
+  return {
+    type: "model",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "README first paragraph",
+    body,
+    target_subdir: "models",
+    slug: "readme-first-paragraph",
+    tags
+  };
+}
+function buildProjectBriefEntry(target, forensic, nowIso, tags) {
+  if (forensic.readme.quality === "missing") {
+    return null;
+  }
+  const readmePath = join(target, "README.md");
+  if (!existsSync(readmePath)) {
+    return null;
+  }
+  const readme = readFileSync(readmePath, "utf8");
+  const description = extractExplicitDescription(readme);
+  if (description === null) {
+    return null;
+  }
+  const body = renderSections({
+    mission: `Capture the explicit project description declared by README.md.`,
+    context: [
+      `Project: ${forensic.project_name}`,
+      "",
+      "Declared description:",
+      "> " + description.split("\n").join("\n> ")
+    ].join("\n")
+  });
+  return {
+    type: "model",
+    layer: "team",
+    maturity: "verified",
+    layer_reason: LAYER_REASON,
+    created_at: nowIso,
+    title: "Project brief",
+    body,
+    target_subdir: "models",
+    slug: "project-brief",
+    tags
+  };
+}
+function renderMarkdown(entry) {
+  const frontmatter = renderFrontmatter(entry);
+  return `${frontmatter}
+
+# ${entry.title}
+
+${entry.body}
+`;
+}
+function renderFrontmatter(entry) {
+  const tagsLine = entry.tags.length > 0 ? `tags: [${entry.tags.join(", ")}]` : "tags: []";
+  const lines = [
+    "---",
+    `id: ${entry.id}`,
+    `type: ${entry.type}`,
+    `layer: ${entry.layer}`,
+    `maturity: ${entry.maturity}`,
+    `layer_reason: ${quoteIfNeeded(entry.layer_reason)}`,
+    `created_at: ${entry.created_at}`,
+    tagsLine,
+    "---"
+  ];
+  return lines.join("\n");
+}
+function renderSections(input) {
+  const parts = [];
+  parts.push(`## [MISSION_STATEMENT]
+
+${input.mission}`);
+  if (input.mandatoryInjection !== void 0) {
+    parts.push(`## [MANDATORY_INJECTION]
+
+${input.mandatoryInjection}`);
+  }
+  if (input.businessLogic !== void 0) {
+    parts.push(`## [BUSINESS_LOGIC_CHUNKS]
+
+${input.businessLogic}`);
+  }
+  parts.push(`## [CONTEXT_INFO]
+
+${input.context}`);
+  return parts.join("\n\n");
+}
+function quoteIfNeeded(value) {
+  return `"${value.replace(/"/g, '\\"')}"`;
+}
+function stripFrontmatter(content) {
+  return content.replace(/^---[\s\S]*?\r?\n---\s*\r?\n?/u, "");
+}
+function deriveTagsFromForensic(forensic) {
+  const MAX_TAGS = 5;
+  const seen = /* @__PURE__ */ new Set();
+  const tags = [];
+  function add(raw) {
+    const normalized = raw.toLowerCase().trim().replace(/\s+/gu, "-");
+    if (normalized.length > 0 && !seen.has(normalized)) {
+      seen.add(normalized);
+      tags.push(normalized);
+    }
+  }
+  if (forensic.framework.kind) {
+    add(forensic.framework.kind);
+  }
+  const SKIP_EXTS = /* @__PURE__ */ new Set([".json", ".md", ".lock", ".yaml", ".yml", ".txt", ".env"]);
+  const EXT_MAP = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".kt": "kotlin"
+  };
+  const byExt = forensic.topology.by_ext ?? {};
+  const sorted = Object.entries(byExt).filter(([ext]) => !SKIP_EXTS.has(ext)).sort(([, a], [, b]) => b - a);
+  for (const [ext] of sorted) {
+    if (tags.length >= MAX_TAGS) break;
+    const mapped = EXT_MAP[ext] ?? ext.replace(/^\./u, "");
+    add(mapped);
+  }
+  return tags.slice(0, MAX_TAGS);
+}
+async function readForensic(forensicPath) {
+  const raw = await readFile(forensicPath, "utf8");
+  return JSON.parse(raw);
+}
+async function readScanState(sidecarPath) {
+  if (!existsSync(sidecarPath)) {
+    return {};
+  }
+  try {
+    const raw = await readFile(sidecarPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+      return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function findExistingIdForFile(sidecar, targetPath, target) {
+  if (!existsSync(targetPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(targetPath, "utf8");
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(raw);
+    if (match === null) {
+      return null;
+    }
+    const idLine = /^id:\s*(.+)$/mu.exec(match[1]);
+    if (idLine === null) {
+      return null;
+    }
+    const candidate = idLine[1].replace(/^["'](.*)["']$/u, "$1").trim();
+    if (/^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/.test(candidate) && sidecar[candidate] !== void 0) {
+      return candidate;
+    }
+    return null;
+  } catch {
+    void target;
+    return null;
+  }
+}
+function isCIConfigPath(path) {
+  return path.startsWith(".github/workflows/") || path.startsWith(".gitlab-ci") || path === "azure-pipelines.yml" || path === ".circleci/config.yml" || path === "Jenkinsfile" || path === ".travis.yml";
+}
+function extractFirstParagraph(readme) {
+  const lines = readme.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && lines[i].trim().length === 0) i += 1;
+  while (i < lines.length && /^#{1,2}\s/.test(lines[i].trim())) {
+    i += 1;
+    while (i < lines.length && lines[i].trim().length === 0) i += 1;
+  }
+  if (i >= lines.length) {
+    return null;
+  }
+  const collected = [];
+  while (i < lines.length && lines[i].trim().length > 0) {
+    if (/^#{1,6}\s/.test(lines[i].trim())) break;
+    collected.push(lines[i]);
+    i += 1;
+  }
+  const paragraph = collected.join("\n").trim();
+  return paragraph.length > 0 ? paragraph : null;
+}
+function extractExplicitDescription(readme) {
+  const headingMatch = /^#{1,6}\s+(?:Description|About|Overview|Summary)\s*\r?\n+([^#][\s\S]*?)(?:\r?\n\r?\n|\r?\n#{1,6}\s|$)/imu.exec(readme);
+  if (headingMatch !== null) {
+    const text = headingMatch[1].trim();
+    if (text.length > 0) return text;
+  }
+  const labelMatch = /^\*\*(?:Description|About|Overview|Summary)\*\*\s*:?\s*(.+?)(?:\r?\n\r?\n|$)/imu.exec(readme);
+  if (labelMatch !== null) {
+    const text = labelMatch[1].trim();
+    if (text.length > 0) return text;
+  }
+  return null;
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+async function registerKnowledgeNodesInMeta(target, entries) {
+  if (entries.length === 0) {
+    return;
+  }
+  const metaPath = join(target, AGENTS_META_FILE);
+  let meta;
+  try {
+    const raw = await readFile(metaPath, "utf8");
+    meta = JSON.parse(raw);
+  } catch {
+    meta = {};
+  }
+  const nodes = typeof meta.nodes === "object" && meta.nodes !== null ? meta.nodes : {};
+  for (const entry of entries) {
+    const contentRef = `${KNOWLEDGE_DIR}/${entry.target_subdir}/${entry.slug}.md`;
+    const absPath = join(target, contentRef);
+    let hash = "";
+    try {
+      const raw = readFileSync(absPath, "utf8");
+      hash = sha256(raw);
+    } catch {
+    }
+    nodes[entry.id] = {
+      file: contentRef,
+      content_ref: contentRef,
+      scope_glob: "**",
+      deps: [],
+      priority: "medium",
+      level: "L1",
+      layer: "L1",
+      topology_type: "cross-cutting",
+      hash,
+      stable_id: entry.id,
+      identity_source: "declared"
+    };
+  }
+  meta.nodes = nodes;
+  await ensureParentDirectory(metaPath);
+  await atomicWriteJson(metaPath, meta);
+}
+async function ensureParentDirectory(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+function printPrettyResult(result) {
+  const writtenCount = result.written_stable_ids.length;
+  const skippedCount = result.skipped_stable_ids.length;
+  if (writtenCount === 0) {
+    console.log(`${symbol.ok} ${paint.success(t("cli.scan.summary.skipped", { count: String(skippedCount) }))}`);
+    return;
+  }
+  console.log(`${symbol.ok} ${paint.success(t("cli.scan.summary.created", { count: String(writtenCount) }))}`);
+  for (const id of result.written_stable_ids) {
+    console.log(`  - ${paint.ai(id)}`);
+  }
+  if (skippedCount > 0) {
+    console.log(paint.muted(`(${skippedCount} unchanged, skipped)`));
+  }
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function getReadmeQuality(target) {
+  const readmePath = join(target, "README.md");
+  if (!existsSync(readmePath)) {
+    return "stub";
+  }
+  const wordCount = readFileSync(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
+  return wordCount >= 200 ? "ok" : "stub";
+}
+function walkFiles(root, ignorePatterns) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    throw new Error(t("cli.shared.target-invalid", { target: root }));
+  }
+  let fileCount = 0;
+  let ignoredCount = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join(current, entry.name);
+      const relativePath = toPosixPath(relative(root, absolutePath));
+      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
+        ignoredCount += 1;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile()) {
+        fileCount += 1;
+      }
+    }
+  }
+  return { fileCount, ignoredCount };
+}
+function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
+  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
+}
+function matchesIgnorePattern(relativePath, isDirectory, pattern) {
+  const normalizedPattern = toPosixPath(pattern);
+  if (normalizedPattern === "**/*.meta") {
+    return relativePath.endsWith(".meta");
+  }
+  if (normalizedPattern.endsWith("/**")) {
+    const directoryPrefix = normalizedPattern.slice(0, -3);
+    return relativePath === directoryPrefix || relativePath.startsWith(`${directoryPrefix}/`) || isDirectory && `${relativePath}/` === directoryPrefix;
+  }
+  return relativePath === normalizedPattern;
+}
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+function buildRecommendations(input) {
+  const recommendations = [];
+  if (!input.hasExistingFabric) {
+    recommendations.push(t("cli.scan.recommendation.init"));
+  }
+  if (input.readmeQuality === "stub") {
+    recommendations.push(t("cli.scan.recommendation.readme"));
+  }
+  if (!input.hasContributing) {
+    recommendations.push(t("cli.scan.recommendation.contributing"));
+  }
+  if (input.framework.kind === "unknown") {
+    recommendations.push(t("cli.scan.recommendation.unknown-framework"));
+  } else {
+    recommendations.push(t("cli.scan.recommendation.framework-dirs", { framework: input.framework.kind }));
+  }
+  return recommendations;
+}
+var __testing__ = {
+  buildTechStackEntry,
+  buildModuleStructureEntry,
+  buildBuildConfigEntry,
+  buildCodeStyleEntry,
+  buildCIConfigEntry,
+  buildReadmeFirstParaEntry,
+  buildProjectBriefEntry,
+  renderMarkdown,
+  stripFrontmatter,
+  isCIConfigPath,
+  extractFirstParagraph,
+  extractExplicitDescription
+};
+
+export {
+  detectFramework,
+  formatKnowledgeId,
+  createScanReport,
+  runInitScan,
+  scanCommand,
+  scan_default,
+  deriveTagsFromForensic,
+  __testing__
+};