@fenglimg/fabric-cli 1.0.0 → 1.1.0

package/dist/init-R73E5YTG.js

@@ -0,0 +1,1164 @@
+#!/usr/bin/env node
+import {
+  createScanReport,
+  detectFramework
+} from "./chunk-JWUO6TIS.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
+import {
+  paint
+} from "./chunk-WWNXR34K.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/init.ts
+import { createHash } from "crypto";
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, statSync as statSync2, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute2, join as join2, parse, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+
+// src/scanner/forensic.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, isAbsolute, join, posix, relative, resolve, sep } from "path";
+import {
+  forensicReportSchema
+} from "@fenglimg/fabric-shared";
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".fabric",
+  ".git",
+  ".next",
+  ".turbo",
+  "Library",
+  "Temp",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var KEY_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+  "app",
+  "components",
+  "pages",
+  "prefabs",
+  "scenes",
+  "scripts",
+  "src"
+]);
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
+var DOMAIN_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".json", ".md"]);
+var EXPECTED_CONFIG_FILES_BY_FRAMEWORK = {
+  "cocos-creator": ["package.json", "project.config.json", "tsconfig.json"],
+  next: ["package.json", "tsconfig.json"],
+  vite: ["package.json", "tsconfig.json"]
+};
+var SAMPLE_LIMIT = 5;
+var SAMPLE_LINE_LIMIT = 30;
+var ENTRY_FAMILY_LIMIT = 1;
+var FAMILY_LIMIT = 3;
+var CANDIDATE_FILE_LIMIT = 12;
+var DEFAULT_SAMPLING_BUDGET = {
+  max_files: 15,
+  max_lines_per_file: 100
+};
+function buildForensicReport(targetInput) {
+  const target = normalizeTarget(targetInput);
+  const framework = detectFramework(target);
+  const topology = buildTopology(target);
+  const entryPoints = collectEntryPoints(topology.files);
+  const codeSamples = buildCodeSamples(target, entryPoints);
+  const assertions = buildAssertions(framework.kind, topology, codeSamples);
+  const candidateFiles = buildCandidateFiles(topology, codeSamples, entryPoints);
+  const readme = readReadmeInfo(target);
+  const report = {
+    version: "1.0",
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    generated_by: `fab-cli@${getCliVersion()}`,
+    target,
+    project_name: readProjectName(target),
+    framework,
+    topology: {
+      total_files: topology.total_files,
+      by_ext: topology.by_ext,
+      key_dirs: topology.key_dirs,
+      max_depth: topology.max_depth
+    },
+    entry_points: entryPoints,
+    code_samples: codeSamples.map(({ pattern_analysis: _patternAnalysis, evidence: _evidence, ...sample }) => sample),
+    assertions,
+    candidate_files: candidateFiles,
+    sampling_budget: DEFAULT_SAMPLING_BUDGET,
+    readme,
+    recommendations_for_skill: buildSkillRecommendations(framework.kind, topology, readme)
+  };
+  const validation = forensicReportSchema.safeParse(report);
+  if (!validation.success) {
+    throw new Error(`ForensicReport schema validation failed: ${validation.error.message}`);
+  }
+  return validation.data;
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function buildTopology(root) {
+  assertExistingDirectory(root);
+  const byExt = {};
+  const keyDirs = /* @__PURE__ */ new Set();
+  const files = [];
+  let totalFiles = 0;
+  let maxDepth = 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 (relativePath.length === 0) {
+        continue;
+      }
+      const depth = relativePath.split("/").length;
+      maxDepth = Math.max(maxDepth, depth);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        if (isKeyDirectory(relativePath)) {
+          keyDirs.add(relativePath);
+        }
+        stack.push(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const stats = statSync(absolutePath);
+      const extension = extname(entry.name) || "[none]";
+      byExt[extension] = (byExt[extension] ?? 0) + 1;
+      totalFiles += 1;
+      files.push({
+        relativePath,
+        sizeBytes: stats.size
+      });
+    }
+  }
+  return {
+    total_files: totalFiles,
+    by_ext: sortRecord(byExt),
+    key_dirs: [...keyDirs].sort(),
+    max_depth: maxDepth,
+    files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
+  };
+}
+function assertExistingDirectory(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) {
+    throw new Error(`Target must be an existing directory: ${target}`);
+  }
+}
+function isKeyDirectory(relativePath) {
+  const name = basename(relativePath);
+  return KEY_DIRECTORY_NAMES.has(name);
+}
+function collectEntryPoints(files) {
+  const entryPoints = [];
+  for (const file of files) {
+    const reason = getEntryPointReason(file.relativePath);
+    if (reason === null) {
+      continue;
+    }
+    entryPoints.push({
+      path: file.relativePath,
+      reason,
+      size_bytes: file.sizeBytes
+    });
+  }
+  return entryPoints;
+}
+function getEntryPointReason(relativePath) {
+  if (!SCRIPT_EXTENSIONS.has(extname(relativePath))) {
+    return null;
+  }
+  const directory = posix.dirname(relativePath);
+  const fileName = basename(relativePath);
+  const fileBase = basename(relativePath, extname(relativePath));
+  if (directory === "assets/scripts" || directory === "scripts") {
+    return "top-level script";
+  }
+  if (directory === "src" && /^(App|app|index|main)$/.test(fileBase)) {
+    return "application entry";
+  }
+  if ((directory === "app" || directory.startsWith("app/")) && /^(layout|page|route)$/.test(fileBase)) {
+    return "next app route";
+  }
+  if ((directory === "pages" || directory.startsWith("pages/")) && fileName !== "_app.d.ts") {
+    return "next page route";
+  }
+  return null;
+}
+function buildCodeSamples(target, entryPoints) {
+  return entryPoints.slice(0, SAMPLE_LIMIT).map((entryPoint) => {
+    const absolutePath = join(target, ...entryPoint.path.split("/"));
+    const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
+    const patternAnalysis = inferPatternHint(entryPoint.path, sample.snippet);
+    return {
+      path: entryPoint.path,
+      lines: `1-${sample.lineCount}`,
+      snippet: sample.snippet,
+      pattern_hint: patternAnalysis.pattern,
+      pattern_analysis: patternAnalysis,
+      evidence: buildEvidenceAnchors(entryPoint.path, sample.snippet, patternAnalysis.evidence_lines)
+    };
+  });
+}
+function readFirstLines(path, lineLimit) {
+  try {
+    const lines = readFileSync(path, "utf8").split(/\r?\n/);
+    if (lines.at(-1) === "") {
+      lines.pop();
+    }
+    const sampledLines = lines.slice(0, lineLimit);
+    return {
+      snippet: sampledLines.join("\n"),
+      lineCount: sampledLines.length
+    };
+  } catch {
+    return {
+      snippet: "",
+      lineCount: 0
+    };
+  }
+}
+function inferPatternHint(relativePath, snippet) {
+  const cocosCoOccurring = compactPatternNames([
+    snippet.includes('from "cc"') || snippet.includes("from 'cc'") ? "cc-import" : null,
+    snippet.includes("@ccclass(") || snippet.includes("ccclass(") ? "ccclass-decorator" : null,
+    snippet.includes("extends Component") ? "component-base" : null,
+    snippet.includes("const { ccclass } = _decorator") ? "decorator-destructure" : null
+  ]);
+  if (cocosCoOccurring.length > 0) {
+    const astLevel = snippet.includes("@ccclass(");
+    return {
+      pattern: "cocos-component-class",
+      type: "pattern",
+      confidence: determineConfidence(1, cocosCoOccurring, astLevel),
+      evidence_lines: compactPatternNames([
+        snippet.includes("_decorator") ? "_decorator" : null,
+        snippet.includes("@ccclass(") ? "@ccclass(" : null,
+        snippet.includes("extends Component") ? "extends Component" : null
+      ]),
+      co_occurring: cocosCoOccurring,
+      family: "component",
+      ast_level: astLevel,
+      statement: "Sampled entry files use Cocos Creator component classes.",
+      proposed_rule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
+      alternatives: ["Generic TypeScript utility module"],
+      rationale: "Cocos-specific decorators and Component inheritance co-occur in sampled entry files."
+    };
+  }
+  const reactCoOccurring = compactPatternNames([
+    snippet.includes("createRoot(") ? "create-root" : null,
+    snippet.includes("ReactDOM.render(") ? "react-dom-render" : null,
+    snippet.includes('from "react-dom"') || snippet.includes("from 'react-dom'") ? "react-dom-import" : null
+  ]);
+  if (reactCoOccurring.length > 0) {
+    return {
+      pattern: "react-root",
+      type: "pattern",
+      confidence: determineConfidence(1, reactCoOccurring, false),
+      evidence_lines: compactPatternNames([
+        snippet.includes("createRoot(") ? "createRoot(" : null,
+        snippet.includes("ReactDOM.render(") ? "ReactDOM.render(" : null
+      ]),
+      co_occurring: reactCoOccurring,
+      family: "entry",
+      ast_level: false,
+      statement: "Sampled entry files bootstrap a React DOM root.",
+      proposed_rule: "Keep root rendering logic in the main application entry file.",
+      alternatives: ["Server-rendered route module"],
+      rationale: "React DOM root markers identify a frontend entrypoint."
+    };
+  }
+  if (relativePath.startsWith("app/") || relativePath.startsWith("pages/")) {
+    const coOccurring = compactPatternNames([
+      relativePath.startsWith("app/") ? "app-router" : null,
+      relativePath.startsWith("pages/") ? "pages-router" : null,
+      snippet.includes("export default") ? "default-export-route" : null
+    ]);
+    return {
+      pattern: "next-route-component",
+      type: "pattern",
+      confidence: determineConfidence(1, coOccurring, false),
+      evidence_lines: compactPatternNames([
+        relativePath.startsWith("app/") ? "app/" : null,
+        relativePath.startsWith("pages/") ? "pages/" : null
+      ]),
+      co_occurring: coOccurring,
+      family: "entry",
+      ast_level: false,
+      statement: "Sampled entry files align with Next.js route modules.",
+      proposed_rule: "Preserve route-segment boundaries when editing app/ or pages/ files.",
+      alternatives: ["Generic source module"],
+      rationale: "Route directory placement anchors these files to the Next.js request surface."
+    };
+  }
+  if (relativePath === "src/main.ts" || relativePath === "src/main.js") {
+    const coOccurring = compactPatternNames([
+      "main-entry",
+      snippet.includes("import.meta") ? "import-meta" : null,
+      snippet.includes("createRoot(") ? "react-root" : null
+    ]);
+    return {
+      pattern: "vite-main-entry",
+      type: "pattern",
+      confidence: determineConfidence(1, coOccurring, false),
+      evidence_lines: ["src/main"],
+      co_occurring: coOccurring,
+      family: "entry",
+      ast_level: false,
+      statement: "Sampled entry files use the conventional Vite main entrypoint.",
+      proposed_rule: "Keep primary bootstrapping logic inside src/main.*.",
+      alternatives: ["Alternative bundler entrypoint"],
+      rationale: "src/main.* is the expected Vite bootstrap path."
+    };
+  }
+  return {
+    pattern: "source-entry",
+    type: "pattern",
+    confidence: "LOW",
+    evidence_lines: [basename(relativePath)],
+    co_occurring: [],
+    family: "domain",
+    ast_level: false,
+    statement: "Sampled entry file appears to be a generic source entry.",
+    alternatives: ["Framework-specific entrypoint"],
+    rationale: "No strong framework markers were detected in the sampled snippet."
+  };
+}
+function readReadmeInfo(target) {
+  const readmePath = join(target, "README.md");
+  const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
+  if (!existsSync(readmePath)) {
+    return {
+      quality: "missing",
+      line_count: 0,
+      has_contributing: hasContributing
+    };
+  }
+  const readme = readFileSync(readmePath, "utf8");
+  const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
+  return {
+    quality: wordCount >= 200 ? "ok" : "stub",
+    line_count: readme.length === 0 ? 0 : readme.split(/\r?\n/).length,
+    has_contributing: hasContributing
+  };
+}
+function buildAssertions(frameworkKind, topology, codeSamples) {
+  const assertions = [
+    buildFrameworkAssertion(frameworkKind, topology, codeSamples),
+    buildDominantPatternAssertion(codeSamples),
+    buildEntryDirectoryAssertion(frameworkKind, codeSamples),
+    buildMetaSidecarAssertion(frameworkKind, topology),
+    buildConfigAssertion(frameworkKind, topology),
+    buildDomainAssertion(codeSamples)
+  ];
+  return assertions.filter((assertion) => assertion !== null);
+}
+function buildCandidateFiles(topology, codeSamples, entryPoints) {
+  const selected = /* @__PURE__ */ new Map();
+  const codeSamplesByPath = new Map(codeSamples.map((sample) => [sample.path, sample]));
+  const configFiles = topology.files.filter((file) => isConfigFile(file.relativePath));
+  const testFiles = topology.files.filter((file) => isTestFile(file.relativePath));
+  const domainFiles = topology.files.filter((file) => isDomainFile(file.relativePath));
+  const componentSamples = codeSamples.filter((sample) => sample.pattern_analysis.family === "component").sort((left, right) => compareCandidateScore(buildComponentCandidateScore(right), buildComponentCandidateScore(left)));
+  addCandidateFamily(
+    selected,
+    entryPoints.map((entryPoint) => ({
+      path: entryPoint.path,
+      family: "entry",
+      rationale: `Representative ${entryPoint.reason} used as an application entry surface.`,
+      score: buildEntryCandidateScore(entryPoint)
+    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
+    ENTRY_FAMILY_LIMIT
+  );
+  addCandidateFamily(
+    selected,
+    componentSamples.map((sample) => ({
+      path: sample.path,
+      family: "component",
+      rationale: sample.pattern_analysis.rationale,
+      score: buildComponentCandidateScore(sample)
+    })),
+    FAMILY_LIMIT
+  );
+  addCandidateFamily(
+    selected,
+    configFiles.map((file) => ({
+      path: file.relativePath,
+      family: "config",
+      rationale: "Bootstrap or compiler configuration file used to infer framework and project boundaries.",
+      score: buildConfigCandidateScore(file.relativePath)
+    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
+    FAMILY_LIMIT
+  );
+  addCandidateFamily(
+    selected,
+    testFiles.map((file) => ({
+      path: file.relativePath,
+      family: "test",
+      rationale: "Existing test coverage surface that captures behavior expectations.",
+      score: file.relativePath.includes("__tests__") ? 2 : 1
+    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
+    FAMILY_LIMIT
+  );
+  addCandidateFamily(
+    selected,
+    domainFiles.filter((file) => !codeSamplesByPath.has(file.relativePath)).map((file) => ({
+      path: file.relativePath,
+      family: "domain",
+      rationale: "Representative domain file outside entry/config/test hotspots.",
+      score: buildDomainCandidateScore(file.relativePath)
+    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
+    FAMILY_LIMIT
+  );
+  return [...selected.values()].slice(0, CANDIDATE_FILE_LIMIT);
+}
+function buildFrameworkAssertion(frameworkKind, topology, codeSamples) {
+  if (frameworkKind === "unknown") {
+    return createAssertion({
+      type: "framework",
+      statement: "Framework could not be determined from the sampled topology.",
+      evidence: codeSamples.flatMap((sample) => sample.evidence).slice(0, 3),
+      matched: 0,
+      total: codeSamples.length,
+      coOccurring: [],
+      alternatives: ["Ask the user to confirm the primary framework"]
+    });
+  }
+  const matchedSamples = codeSamples.filter((sample) => matchesFrameworkPattern(frameworkKind, sample.pattern_analysis.pattern));
+  const coOccurring = compactPatternNames([
+    ...matchedSamples.flatMap((sample) => sample.pattern_analysis.co_occurring),
+    hasFile(topology.files, "project.config.json") ? "project-config-json" : null,
+    (topology.by_ext[".meta"] ?? 0) > 0 ? "meta-sidecars" : null,
+    hasFile(topology.files, "package.json") ? "package-json" : null
+  ]);
+  const evidence = [
+    ...matchedSamples.flatMap((sample) => sample.evidence),
+    ...buildTopologyEvidence(topology, getExpectedConfigFiles(frameworkKind))
+  ].slice(0, 3);
+  return createAssertion({
+    type: "framework",
+    statement: buildFrameworkStatement(frameworkKind),
+    evidence,
+    matched: matchedSamples.length,
+    total: codeSamples.length,
+    coOccurring,
+    astLevel: matchedSamples.some((sample) => sample.pattern_analysis.ast_level),
+    proposedRule: buildFrameworkRule(frameworkKind),
+    alternatives: frameworkKind === "cocos-creator" ? ["Generic TypeScript utility modules"] : ["Alternative framework entry layout"]
+  });
+}
+function buildDominantPatternAssertion(codeSamples) {
+  if (codeSamples.length === 0) {
+    return null;
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const sample of codeSamples) {
+    const existing = counts.get(sample.pattern_analysis.pattern) ?? [];
+    existing.push(sample);
+    counts.set(sample.pattern_analysis.pattern, existing);
+  }
+  const dominant = [...counts.entries()].sort((left, right) => right[1].length - left[1].length)[0];
+  if (dominant === void 0) {
+    return null;
+  }
+  const [, samples] = dominant;
+  const first = samples[0];
+  return createAssertion({
+    type: first.pattern_analysis.type,
+    statement: first.pattern_analysis.statement,
+    evidence: samples.flatMap((sample) => sample.evidence).slice(0, 3),
+    matched: samples.length,
+    total: codeSamples.length,
+    coOccurring: compactPatternNames(samples.flatMap((sample) => sample.pattern_analysis.co_occurring)),
+    astLevel: samples.some((sample) => sample.pattern_analysis.ast_level),
+    proposedRule: first.pattern_analysis.proposed_rule,
+    alternatives: first.pattern_analysis.alternatives
+  });
+}
+function buildEntryDirectoryAssertion(frameworkKind, codeSamples) {
+  if (codeSamples.length === 0) {
+    return null;
+  }
+  const directoryGroups = /* @__PURE__ */ new Map();
+  for (const sample of codeSamples) {
+    const directory2 = posix.dirname(sample.path);
+    const existing = directoryGroups.get(directory2) ?? [];
+    existing.push(sample);
+    directoryGroups.set(directory2, existing);
+  }
+  const primaryDirectory = [...directoryGroups.entries()].sort((left, right) => right[1].length - left[1].length)[0];
+  if (primaryDirectory === void 0) {
+    return null;
+  }
+  const [directory, samples] = primaryDirectory;
+  return createAssertion({
+    type: "pattern",
+    statement: `Entry samples are concentrated in ${directory}, indicating a stable primary source boundary.`,
+    evidence: samples.flatMap((sample) => sample.evidence).slice(0, 3),
+    matched: samples.length,
+    total: codeSamples.length,
+    coOccurring: compactPatternNames([
+      directory === "." ? "root-entry" : directory,
+      frameworkKind !== "unknown" ? frameworkKind : null,
+      ...samples.flatMap((sample) => sample.pattern_analysis.co_occurring.slice(0, 1))
+    ]),
+    proposedRule: directory === "." ? "Keep primary entry files at the repository root only if the framework expects it." : `Treat ${directory} as the main execution boundary during initialization.`
+  });
+}
+function buildMetaSidecarAssertion(frameworkKind, topology) {
+  const relevantScripts = topology.files.filter((file) => SCRIPT_EXTENSIONS.has(extname(file.relativePath)));
+  if (relevantScripts.length === 0) {
+    return null;
+  }
+  const matchedScripts = relevantScripts.filter((file) => hasFile(topology.files, `${file.relativePath}.meta`));
+  if (matchedScripts.length === 0 && frameworkKind !== "cocos-creator") {
+    return null;
+  }
+  return createAssertion({
+    type: "invariant",
+    statement: matchedScripts.length > 0 ? "Script files have adjacent .meta sidecars, which should be treated as coupled assets." : "No .meta sidecars were detected for sampled scripts.",
+    evidence: matchedScripts.length > 0 ? matchedScripts.slice(0, 3).map((file) => makeSyntheticEvidence(`${file.relativePath}.meta`, `${file.relativePath}.meta sidecar present`)) : buildTopologyEvidence(topology, relevantScripts.slice(0, 1).map((file) => file.relativePath)),
+    matched: matchedScripts.length,
+    total: relevantScripts.length,
+    coOccurring: compactPatternNames([
+      matchedScripts.length > 0 ? "meta-sidecar" : null,
+      frameworkKind === "cocos-creator" ? "cocos-creator" : null,
+      relevantScripts.some((file) => file.relativePath.startsWith("assets/scripts/")) ? "assets-scripts" : null
+    ]),
+    proposedRule: matchedScripts.length > 0 ? "Do not edit or delete .meta sidecars without explicit user confirmation." : void 0
+  });
+}
+function buildConfigAssertion(frameworkKind, topology) {
+  const expectedFiles = getExpectedConfigFiles(frameworkKind);
+  if (expectedFiles.length === 0) {
+    return null;
+  }
+  const matchedFiles = expectedFiles.filter((file) => hasFile(topology.files, file));
+  return createAssertion({
+    type: "invariant",
+    statement: `Project configuration is anchored by ${expectedFiles.join(", ")}.`,
+    evidence: buildTopologyEvidence(topology, matchedFiles),
+    matched: matchedFiles.length,
+    total: expectedFiles.length,
+    coOccurring: compactPatternNames(matchedFiles.map(normalizeConfigPattern)),
+    proposedRule: "Read bootstrap and compiler config before generating new rules or project structure."
+  });
+}
+function buildDomainAssertion(codeSamples) {
+  if (codeSamples.length === 0) {
+    return null;
+  }
+  const namedSamples = codeSamples.filter((sample) => {
+    const fileBase = basename(sample.path, extname(sample.path));
+    return sample.snippet.includes(`class ${fileBase}`) || sample.snippet.includes(`class ${sanitizeIdentifier(fileBase)}`);
+  });
+  if (namedSamples.length === 0) {
+    return null;
+  }
+  const namedModules = compactPatternNames(namedSamples.map((sample) => basename(sample.path, extname(sample.path))));
+  return createAssertion({
+    type: "domain",
+    statement: `Sampled modules are named as concrete domain concepts (${namedModules.join(", ")}).`,
+    evidence: namedSamples.flatMap((sample) => sample.evidence).slice(0, 3),
+    matched: namedSamples.length,
+    total: codeSamples.length,
+    coOccurring: compactPatternNames([
+      namedSamples.every((sample) => /^[A-Z]/.test(basename(sample.path))) ? "pascal-case-modules" : null,
+      namedModules.length >= 2 ? "domain-named-components" : null,
+      namedSamples.some((sample) => sample.snippet.includes("start():")) ? "lifecycle-hook" : null
+    ]),
+    proposedRule: "Preserve domain-specific module names when mirroring structure into AGENTS.md or .fabric/agents/."
+  });
+}
+function createAssertion(input) {
+  const coverage = {
+    ratio: input.total === 0 ? 0 : roundCoverageRatio(input.matched / input.total),
+    total: input.total,
+    matched: input.matched,
+    co_occurring_patterns: compactPatternNames(input.coOccurring)
+  };
+  return {
+    type: input.type,
+    statement: input.statement,
+    confidence: determineConfidence(coverage.ratio, coverage.co_occurring_patterns, input.astLevel ?? false),
+    evidence: dedupeEvidence(input.evidence),
+    coverage,
+    proposed_rule: input.proposedRule,
+    alternatives: input.alternatives
+  };
+}
+function buildEvidenceAnchors(relativePath, snippet, evidenceLines) {
+  const lines = snippet.split("\n");
+  const anchors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of evidenceLines) {
+    const lineIndex = lines.findIndex((line) => line.includes(pattern));
+    if (lineIndex === -1) {
+      continue;
+    }
+    const key = `${relativePath}:${lineIndex + 1}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    anchors.push({
+      file: relativePath,
+      line: String(lineIndex + 1),
+      snippet: lines[lineIndex]?.trim() ?? ""
+    });
+  }
+  if (anchors.length > 0) {
+    return anchors;
+  }
+  const fallbackIndex = lines.findIndex((line) => line.trim().length > 0);
+  return [
+    {
+      file: relativePath,
+      line: String(fallbackIndex === -1 ? 1 : fallbackIndex + 1),
+      snippet: fallbackIndex === -1 ? "" : lines[fallbackIndex]?.trim() ?? ""
+    }
+  ];
+}
+function addCandidateFamily(selected, candidates, familyLimit) {
+  let added = 0;
+  for (const candidate of candidates) {
+    if (selected.size >= CANDIDATE_FILE_LIMIT || added >= familyLimit || selected.has(candidate.path)) {
+      continue;
+    }
+    selected.set(candidate.path, {
+      path: candidate.path,
+      family: candidate.family,
+      rationale: candidate.rationale
+    });
+    added += 1;
+  }
+}
+function buildTopologyEvidence(topology, preferredPaths) {
+  return preferredPaths.filter((path) => hasFile(topology.files, path)).slice(0, 3).map((path) => makeSyntheticEvidence(path, `${path} present in project topology`));
+}
+function makeSyntheticEvidence(file, snippet) {
+  return {
+    file,
+    line: "1",
+    snippet
+  };
+}
+function dedupeEvidence(evidence) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of evidence) {
+    const key = `${entry.file}:${entry.line}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(entry);
+  }
+  return deduped.slice(0, 3);
+}
+function matchesFrameworkPattern(frameworkKind, pattern) {
+  if (frameworkKind === "cocos-creator") {
+    return pattern === "cocos-component-class";
+  }
+  if (frameworkKind === "next") {
+    return pattern === "next-route-component";
+  }
+  if (frameworkKind === "vite") {
+    return pattern === "vite-main-entry" || pattern === "react-root";
+  }
+  return pattern !== "source-entry";
+}
+function buildFrameworkStatement(frameworkKind) {
+  if (frameworkKind === "cocos-creator") {
+    return "Project strongly matches a Cocos Creator TypeScript component layout.";
+  }
+  if (frameworkKind === "next") {
+    return "Project topology and entry samples align with a Next.js route-driven application.";
+  }
+  if (frameworkKind === "vite") {
+    return "Project topology aligns with a Vite-style application bootstrap.";
+  }
+  return `Project surfaces align with ${frameworkKind}.`;
+}
+function buildFrameworkRule(frameworkKind) {
+  if (frameworkKind === "cocos-creator") {
+    return "Preserve Cocos component decorators, lifecycle methods, and paired .meta files during initialization.";
+  }
+  if (frameworkKind === "next") {
+    return "Respect app/pages route boundaries when generating instructions or edits.";
+  }
+  if (frameworkKind === "vite") {
+    return "Keep bootstrap logic centered on src/main.* and surrounding config files.";
+  }
+  return void 0;
+}
+function determineConfidence(ratio, coOccurringPatterns, astLevel, hasConflict = false) {
+  if (hasConflict) {
+    return "LOW";
+  }
+  if (astLevel) {
+    return "HIGH";
+  }
+  if (ratio < 0.5) {
+    return "LOW";
+  }
+  if (ratio >= 0.8 && coOccurringPatterns.length >= 2) {
+    return "HIGH";
+  }
+  return "MEDIUM";
+}
+function compactPatternNames(patterns) {
+  return [...new Set(patterns.filter((pattern) => pattern !== null && pattern !== void 0 && pattern.length > 0))];
+}
+function roundCoverageRatio(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function getExpectedConfigFiles(frameworkKind) {
+  return EXPECTED_CONFIG_FILES_BY_FRAMEWORK[frameworkKind] ?? ["package.json"];
+}
+function hasFile(files, relativePath) {
+  return files.some((file) => file.relativePath === relativePath);
+}
+function normalizeConfigPattern(relativePath) {
+  return relativePath.replace(/\./g, "-");
+}
+function sanitizeIdentifier(value) {
+  return value.replace(/[^A-Za-z0-9_$]/g, "");
+}
+function compareCandidateScore(left, right) {
+  return left - right;
+}
+function buildEntryCandidateScore(entryPoint) {
+  let score = 0;
+  if (entryPoint.reason === "application entry") {
+    score += 3;
+  }
+  if (entryPoint.reason.includes("route")) {
+    score += 2;
+  }
+  if ((entryPoint.size_bytes ?? 0) > 0) {
+    score += 1;
+  }
+  return score;
+}
+function buildComponentCandidateScore(sample) {
+  let score = sample.pattern_analysis.co_occurring.length;
+  if (sample.pattern_analysis.ast_level) {
+    score += 3;
+  }
+  if (sample.pattern_analysis.confidence === "HIGH") {
+    score += 2;
+  }
+  return score;
+}
+function buildConfigCandidateScore(relativePath) {
+  if (relativePath === "project.config.json") {
+    return 4;
+  }
+  if (relativePath === "package.json") {
+    return 3;
+  }
+  if (relativePath === "tsconfig.json") {
+    return 2;
+  }
+  return 1;
+}
+function buildDomainCandidateScore(relativePath) {
+  let score = 0;
+  if (relativePath.startsWith("src/") || relativePath.startsWith("assets/")) {
+    score += 2;
+  }
+  if (SCRIPT_EXTENSIONS.has(extname(relativePath))) {
+    score += 1;
+  }
+  if (relativePath.includes("/domain/") || relativePath.includes("/models/")) {
+    score += 1;
+  }
+  return score;
+}
+function isConfigFile(relativePath) {
+  return /(^|\/)(package\.json|project\.config\.json|tsconfig\.json|vite\.config\.[^.]+|next\.config\.[^.]+)$/.test(relativePath);
+}
+function isTestFile(relativePath) {
+  return /(^|\/)(__tests__|tests)(\/|$)/.test(relativePath) || /\.(test|spec)\.[^.]+$/.test(relativePath);
+}
+function isDomainFile(relativePath) {
+  const extension = extname(relativePath);
+  if (!DOMAIN_FILE_EXTENSIONS.has(extension)) {
+    return false;
+  }
+  return !isConfigFile(relativePath) && !isTestFile(relativePath);
+}
+function buildSkillRecommendations(frameworkKind, topology, readme) {
+  const recommendations = [];
+  if (frameworkKind === "cocos-creator") {
+    recommendations.push("\u5EFA\u8BAE\u5411\u7528\u6237\u786E\u8BA4 Cocos Creator Component \u751F\u547D\u5468\u671F(onLoad/onEnable/start)\u987A\u5E8F\u3002");
+    recommendations.push("\u5EFA\u8BAE\u8BE2\u95EE assets/prefabs \u548C assets/scenes \u662F\u5426\u5C5E\u4E8E @HUMAN \u4FDD\u62A4\u533A\u57DF\u3002");
+    if ((topology.by_ext[".meta"] ?? 0) > 0) {
+      recommendations.push("\u68C0\u6D4B\u5230 .meta \u6587\u4EF6,\u5EFA\u8BAE\u5728 @HUMAN \u9501\u5B9A .meta \u4E0D\u88AB AI \u6539\u52A8\u3002");
+    }
+  } else if (frameworkKind === "next") {
+    recommendations.push("\u5EFA\u8BAE\u786E\u8BA4 app/pages \u8DEF\u7531\u8FB9\u754C\u548C\u670D\u52A1\u7AEF\u7EC4\u4EF6\u7EA6\u675F\u3002");
+  } else if (frameworkKind === "vite") {
+    recommendations.push("\u5EFA\u8BAE\u786E\u8BA4 src/main \u5165\u53E3\u3001\u7EC4\u4EF6\u76EE\u5F55\u548C\u6784\u5EFA\u811A\u672C\u7684\u7EF4\u62A4\u8FB9\u754C\u3002");
+  } else if (frameworkKind === "unknown") {
+    recommendations.push("\u672A\u68C0\u6D4B\u5230\u660E\u786E\u6846\u67B6,\u5EFA\u8BAE\u5148\u8BA9\u7528\u6237\u786E\u8BA4\u6280\u672F\u6808\u548C\u4E3B\u8981\u5165\u53E3\u3002");
+  } else {
+    recommendations.push(`\u5EFA\u8BAE\u56F4\u7ED5 ${frameworkKind} \u7684\u4E3B\u8981\u5165\u53E3\u548C\u751F\u6210\u76EE\u5F55\u786E\u8BA4 AGENTS.md \u5206\u5C42\u8FB9\u754C\u3002`);
+  }
+  if (readme.quality !== "ok") {
+    recommendations.push("README \u4FE1\u606F\u4E0D\u8DB3,\u5EFA\u8BAE\u5728\u521D\u59CB\u5316\u8BBF\u8C08\u4E2D\u8865\u9F50\u9879\u76EE\u76EE\u6807\u3001\u8FD0\u884C\u65B9\u5F0F\u548C\u7981\u6539\u533A\u57DF\u3002");
+  }
+  return recommendations;
+}
+function readProjectName(target) {
+  const packageJsonPath = join(target, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
+        return packageJson.name;
+      }
+    } catch {
+      return basename(target);
+    }
+  }
+  return basename(target);
+}
+function getCliVersion() {
+  return true ? "1.1.0" : "unknown";
+}
+function sortRecord(record) {
+  return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+
+// src/commands/init.ts
+var AGENTS_TEMPLATE_BY_FRAMEWORK = {
+  "cocos-creator": "templates/agents-md/variants/cocos.md",
+  vite: "templates/agents-md/variants/vite.md",
+  next: "templates/agents-md/variants/next.md"
+};
+var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/agents-md-init/SKILL.md";
+var CLAUDE_INIT_REMINDER_HOOK_TEMPLATE = "templates/claude-hooks/agents-md-init-reminder.cjs";
+var CLAUDE_INIT_REMINDER_COMMAND = ".claude/hooks/agents-md-init-reminder.cjs";
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: t("cli.init.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.init.args.target.description")
+    },
+    debug: {
+      type: "boolean",
+      description: t("cli.init.args.debug.description"),
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createDebugLogger(args.debug);
+    const resolution = resolveDevMode(args.target, process.cwd());
+    const target = normalizeTarget2(resolution.target);
+    logger(`init target source: ${resolution.source}`);
+    for (const step of resolution.chain) {
+      logger(step);
+    }
+    const created = initFabric(target);
+    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.agentsPath }));
+    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.metaPath }));
+    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.humanLockPath }));
+    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.forensicPath }));
+    writeStderr(
+      created.claudeSkillAction === "created" ? t("cli.init.created-path", { label: createdLabel(), path: created.claudeSkillPath }) : t("cli.init.skipped-existing-path", { label: skippedLabel(), path: created.claudeSkillPath })
+    );
+    writeStderr(
+      created.claudeHookAction === "created" ? t("cli.init.created-path", { label: createdLabel(), path: created.claudeHookPath }) : t("cli.init.skipped-existing-path", { label: skippedLabel(), path: created.claudeHookPath })
+    );
+    writeStderr(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
+    console.log(
+      t("cli.init.next-step", {
+        label: nextLabel(),
+        message: paint.muted(t("cli.init.next-step.message"))
+      })
+    );
+    console.log(
+      t("cli.init.reason-message", {
+        label: reasonLabel(),
+        message: paint.muted(t("cli.init.reason-message.body"))
+      })
+    );
+  }
+});
+var init_default = initCommand;
+function initFabric(target) {
+  assertExistingDirectory2(target);
+  const agentsPath = join2(target, "AGENTS.md");
+  const fabricDir = join2(target, ".fabric");
+  const forensicPath = join2(fabricDir, "forensic.json");
+  const claudeSkillPath = join2(target, ".claude", "skills", "agents-md-init", "SKILL.md");
+  const claudeHookPath = join2(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
+  const claudeSettingsPath = join2(target, ".claude", "settings.json");
+  if (existsSync2(forensicPath)) {
+    throw new Error(`ABORT: ${forensicPath} already exists. fab init is non-destructive.`);
+  }
+  if (existsSync2(agentsPath)) {
+    throw new Error(`ABORT: ${agentsPath} already exists. fab init is non-destructive.`);
+  }
+  if (existsSync2(fabricDir)) {
+    throw new Error(`ABORT: ${fabricDir} already exists. fab init is non-destructive.`);
+  }
+  const scanReport = createScanReport(target);
+  const forensicReport = buildForensicReport(target);
+  const template = readFileSync2(findAgentsTemplatePath(scanReport.framework.kind), "utf8");
+  const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
+  const packageName = readPackageName(target) ?? parse(target).base;
+  const agentsContent = template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind);
+  const agentsHash = sha256(agentsContent);
+  const meta = createInitialMeta(agentsHash);
+  const metaPath = join2(fabricDir, "agents.meta.json");
+  const humanLockPath = join2(fabricDir, "human-lock.json");
+  mkdirSync(fabricDir, { recursive: false });
+  writeNewFile(agentsPath, agentsContent);
+  writeNewFile(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+  writeNewFile(humanLockPath, humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
+`);
+  writeNewFile(forensicPath, `${JSON.stringify(forensicReport, null, 2)}
+`);
+  const claudeSkillAction = copyTemplateIfMissing(findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), claudeSkillPath);
+  const claudeHookAction = copyExecutableTemplateIfMissing(
+    findTemplatePath(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
+    claudeHookPath
+  );
+  const claudeSettingsAction = mergeClaudeStopHook(claudeSettingsPath);
+  return {
+    agentsPath,
+    metaPath,
+    humanLockPath,
+    forensicPath,
+    claudeSkillPath,
+    claudeSkillAction,
+    claudeHookPath,
+    claudeHookAction,
+    claudeSettingsPath,
+    claudeSettingsAction
+  };
+}
+function findAgentsTemplatePath(frameworkKind) {
+  const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
+  return findTemplatePath(relativePath);
+}
+function normalizeTarget2(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
+}
+function assertExistingDirectory2(target) {
+  if (!existsSync2(target) || !statSync2(target).isDirectory()) {
+    throw new Error(`Target must be an existing directory: ${target}`);
+  }
+}
+function createInitialMeta(agentsHash) {
+  return {
+    revision: sha256(agentsHash),
+    nodes: {
+      L0: {
+        file: "AGENTS.md",
+        scope_glob: "**",
+        deps: [],
+        priority: "high",
+        layer: "L0",
+        topology_type: "mirror",
+        hash: agentsHash
+      }
+    }
+  };
+}
+function readPackageName(target) {
+  const packageJsonPath = join2(target, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return void 0;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+    return packageJson.name;
+  } catch {
+    return void 0;
+  }
+}
+function findTemplatePath(relativePath) {
+  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    ...templateCandidatesFrom(process.cwd(), relativePath),
+    ...templateCandidatesFrom(currentModuleDir, relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
+}
+function templateCandidatesFrom(start, relativePath) {
+  const candidates = [];
+  let current = resolve2(start);
+  while (true) {
+    candidates.push(join2(current, ...relativePath.split("/")));
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates.reverse();
+}
+function writeNewFile(path, content) {
+  if (existsSync2(path)) {
+    throw new Error(`ABORT: ${path} already exists. fab init is non-destructive.`);
+  }
+  writeFileSync(path, content, "utf8");
+}
+function copyTemplateIfMissing(templatePath, targetPath) {
+  mkdirSync(dirname(targetPath), { recursive: true });
+  if (existsSync2(targetPath)) {
+    return "skipped";
+  }
+  copyFileSync(templatePath, targetPath);
+  return "created";
+}
+function copyExecutableTemplateIfMissing(templatePath, targetPath) {
+  const action = copyTemplateIfMissing(templatePath, targetPath);
+  if (action === "created") {
+    chmodSync(targetPath, 493);
+  }
+  return action;
+}
+function mergeClaudeStopHook(settingsPath) {
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  let settings;
+  let action = "updated";
+  if (!existsSync2(settingsPath)) {
+    settings = {};
+    action = "created";
+  } else {
+    try {
+      const parsed = JSON.parse(readFileSync2(settingsPath, "utf8"));
+      if (!isRecord(parsed)) {
+        writeStderr(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
+        return "skipped-invalid";
+      }
+      settings = parsed;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "unknown parse error";
+      writeStderr(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
+      return "skipped-invalid";
+    }
+  }
+  if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
+    writeStderr(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
+    return "skipped-invalid";
+  }
+  const hooks = settings.hooks ?? {};
+  const stopHooksValue = hooks.Stop;
+  if (stopHooksValue !== void 0 && !Array.isArray(stopHooksValue)) {
+    writeStderr(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
+    return "skipped-invalid";
+  }
+  const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
+  if (hasClaudeInitReminderHook(stopHooks)) {
+    return "skipped";
+  }
+  stopHooks.push({
+    matcher: "*",
+    hooks: [
+      {
+        type: "command",
+        command: CLAUDE_INIT_REMINDER_COMMAND
+      }
+    ]
+  });
+  settings.hooks = {
+    ...hooks,
+    Stop: stopHooks
+  };
+  writeJsonAtomically(settingsPath, settings);
+  return action;
+}
+function hasClaudeInitReminderHook(stopHooks) {
+  return stopHooks.some((entry) => {
+    if (!isRecord(entry) || !Array.isArray(entry.hooks)) {
+      return false;
+    }
+    return entry.hooks.some(
+      (hook) => isRecord(hook) && hook.type === "command" && typeof hook.command === "string" && hook.command.includes("agents-md-init-reminder.cjs")
+    );
+  });
+}
+function writeJsonAtomically(path, value) {
+  const tempPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  renameSync(tempPath, path);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatClaudeSettingsAction(settingsPath, action) {
+  switch (action) {
+    case "created":
+      return t("cli.init.claude-settings.created", { label: createdLabel(), path: settingsPath });
+    case "updated":
+      return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
+    case "skipped":
+      return t("cli.init.claude-settings.skipped", { label: skippedLabel(), path: settingsPath });
+    case "skipped-invalid":
+      return t("cli.init.claude-settings.skipped-invalid", { label: skippedLabel(), path: settingsPath });
+    default:
+      return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
+  }
+}
+function createdLabel() {
+  return paint.success(t("cli.shared.created"));
+}
+function skippedLabel() {
+  return paint.muted(t("cli.shared.skipped"));
+}
+function nextLabel() {
+  return paint.ai(t("cli.shared.next"));
+}
+function reasonLabel() {
+  return paint.human(t("cli.shared.reason"));
+}
+function updatedLabel() {
+  return paint.success(t("cli.shared.updated"));
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+export {
+  init_default as default,
+  initCommand,
+  initFabric
+};