@fenglimg/fabric-cli 1.4.0 → 1.5.0

package/README.md

@@ -13,14 +13,18 @@
 
 `fabric bootstrap install` refreshes the internal bootstrap guide at `.fabric/bootstrap/README.md`. It does not generate root `AGENTS.md`, `CLAUDE.md`, or `GEMINI.md`.
 
-## Common Commands
-
-- `fabric init`
-- `fabric serve`
-- `fabric doctor --audit`
-
-## Advanced Commands
-
-- `fabric bootstrap install`
-- `fabric config install`
-- `fabric hooks install`
+## Common Commands
+
+- `fabric init`
+- `fabric serve`
+- `fabric doctor --audit`
+- `fabric approve --interactive`
+- `fabric approve --all`
+
+## Advanced Commands
+
+- `fabric bootstrap install`
+- `fabric config install`
+- `fabric hooks install`
+
+`fabric approve` updates drifted entries in `.fabric/human-lock.json` after review. Use `--interactive` for per-entry confirmation and `--all` only when drift has already been reviewed elsewhere.

package/dist/approve-YT4DEABS.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  padEnd
+} from "./chunk-WWNXR34K.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/approve.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { isAbsolute, resolve } from "path";
+import { approveHumanLock, readHumanLock } from "@fenglimg/fabric-server";
+import { defineCommand, renderUsage } from "citty";
+var approveCommand = defineCommand({
+  meta: {
+    name: "approve",
+    description: t("cli.approve.description")
+  },
+  args: {
+    all: {
+      type: "boolean",
+      description: t("cli.approve.args.all.description"),
+      default: false
+    },
+    interactive: {
+      type: "boolean",
+      description: t("cli.approve.args.interactive.description"),
+      default: false
+    },
+    target: {
+      type: "string",
+      description: t("cli.approve.args.target.description"),
+      default: process.cwd()
+    }
+  },
+  async run({ args }) {
+    const target = normalizeTarget(args.target);
+    if (args.all === args.interactive) {
+      writeStdout(await renderUsage(approveCommand));
+      process.exitCode = 1;
+      return;
+    }
+    if (args.all) {
+      await runApproveAll(target);
+      return;
+    }
+    await runApproveInteractive(target);
+  }
+});
+var approve_default = approveCommand;
+async function runApproveAll(projectRoot) {
+  const driftEntries = await readDriftEntries(projectRoot);
+  if (driftEntries.length === 0) {
+    writeStdout(t("cli.approve.no-drift"));
+    return;
+  }
+  let approvedCount = 0;
+  for (const entry of driftEntries) {
+    await approveEntry(projectRoot, entry);
+    approvedCount += 1;
+  }
+  writeStdout(t("cli.approve.summary", { approved: String(approvedCount), skipped: "0", total: String(driftEntries.length) }));
+}
+async function runApproveInteractive(projectRoot) {
+  const driftEntries = await readDriftEntries(projectRoot);
+  if (driftEntries.length === 0) {
+    writeStdout(t("cli.approve.no-drift"));
+    return;
+  }
+  const rl = createInterface({ input, output });
+  let approvedCount = 0;
+  let skippedCount = 0;
+  try {
+    for (const entry of driftEntries) {
+      writeStdout(formatEntry(entry));
+      const answer = (await rl.question(t("cli.approve.prompt"))).trim().toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        await approveEntry(projectRoot, entry);
+        approvedCount += 1;
+        writeStdout(t("cli.approve.approved-one", { location: formatLocation(entry) }));
+        continue;
+      }
+      skippedCount += 1;
+      writeStdout(t("cli.approve.skipped-one", { location: formatLocation(entry) }));
+    }
+  } finally {
+    rl.close();
+  }
+  writeStdout(
+    t("cli.approve.summary", {
+      approved: String(approvedCount),
+      skipped: String(skippedCount),
+      total: String(driftEntries.length)
+    })
+  );
+}
+async function readDriftEntries(projectRoot) {
+  const entries = await readHumanLock(projectRoot);
+  return entries.filter((entry) => entry.drift);
+}
+async function approveEntry(projectRoot, entry) {
+  await approveHumanLock(projectRoot, {
+    file: entry.file,
+    start_line: entry.start_line,
+    end_line: entry.end_line,
+    new_hash: entry.current_hash
+  });
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function formatEntry(entry) {
+  return [
+    formatLocation(entry),
+    `${padEnd(t("cli.approve.table.expected"), 10)} ${shortenHash(entry.hash)}`,
+    `${padEnd(t("cli.approve.table.current"), 10)} ${shortenHash(entry.current_hash)}`
+  ].join("\n");
+}
+function formatLocation(entry) {
+  return `${entry.file}:${entry.start_line}-${entry.end_line}`;
+}
+function shortenHash(value) {
+  if (value === "missing") {
+    return t("cli.shared.missing");
+  }
+  return value.slice(0, 15);
+}
+function writeStdout(message) {
+  process.stdout.write(`${message}
+`);
+}
+export {
+  approveCommand,
+  approve_default as default,
+  runApproveAll,
+  runApproveInteractive
+};

package/dist/{bootstrap-B6RCVJZJ.js → bootstrap-VGL3AR26.js}

@@ -3,11 +3,11 @@ import {
   bootstrapCommand,
   bootstrap_default,
   installBootstrap
-} from "./chunk-XQYY2U2C.js";
-import "./chunk-AZRKMFRY.js";
-import "./chunk-BEKSXO5N.js";
+} from "./chunk-T2WJF5I3.js";
+import "./chunk-QSAEGVKE.js";
 import "./chunk-AEOYCVBG.js";
 import "./chunk-WWNXR34K.js";
+import "./chunk-BEKSXO5N.js";
 import "./chunk-6ICJICVU.js";
 export {
   bootstrapCommand,

package/dist/{chunk-AZRKMFRY.js → chunk-QSAEGVKE.js}

@@ -40,7 +40,7 @@ function resolveIgnores(fabricConfig) {
 }
 
 // src/commands/scan.ts
-function createScanReport(targetInput = process.cwd(), fabricConfig) {
+async function createScanReport(targetInput = process.cwd(), fabricConfig) {
   const target = normalizeTarget(targetInput);
   const framework = detectFramework(target);
   const readmeQuality = getReadmeQuality(target);
@@ -93,7 +93,7 @@ var scanCommand = defineCommand({
     for (const step of resolution.chain) {
       logger(step);
     }
-    const report = createScanReport(resolution.target, fabricConfig);
+    const report = await createScanReport(resolution.target, fabricConfig);
     if (args.json) {
       console.log(JSON.stringify(report, null, 2));
       return;

package/dist/{chunk-XQYY2U2C.js → chunk-T2WJF5I3.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   createScanReport
-} from "./chunk-AZRKMFRY.js";
-import {
-  resolveClients
-} from "./chunk-BEKSXO5N.js";
+} from "./chunk-QSAEGVKE.js";
 import {
   readFabricConfig
 } from "./chunk-AEOYCVBG.js";
+import {
+  resolveClients
+} from "./chunk-BEKSXO5N.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -26,22 +26,22 @@ var AGENTS_TEMPLATE_BY_FRAMEWORK = {
   next: "templates/agents-md/variants/next.md"
 };
 var FABRIC_GUIDE_PATH = ".fabric/bootstrap/README.md";
-function buildFabricBootstrapGuide(target) {
+async function buildFabricBootstrapGuide(target) {
   const workspaceRoot = normalizeTarget(target);
-  const scanReport = createScanReport(workspaceRoot);
+  const scanReport = await createScanReport(workspaceRoot);
   const template = readFileSync(findBootstrapTemplatePath(scanReport.framework.kind), "utf8");
   const packageName = readPackageName(workspaceRoot) ?? parse(workspaceRoot).base;
   return ensureTrailingNewline(
     template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind)
   );
 }
-function ensureFabricBootstrapGuide(workspaceRoot, force) {
+async function ensureFabricBootstrapGuide(workspaceRoot, force) {
   const guidePath = resolve(workspaceRoot, FABRIC_GUIDE_PATH);
   if (existsSync(guidePath) && !force) {
     return;
   }
   mkdirSync(dirname(guidePath), { recursive: true });
-  writeFileSync(guidePath, buildFabricBootstrapGuide(workspaceRoot), "utf8");
+  writeFileSync(guidePath, await buildFabricBootstrapGuide(workspaceRoot), "utf8");
 }
 function findBootstrapTemplatePath(frameworkKind) {
   const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
@@ -170,7 +170,7 @@ async function installBootstrap(target, options = {}) {
   const installed = [];
   const skipped = [];
   const details = [];
-  ensureFabricBootstrapGuide(workspaceRoot, options.force);
+  await ensureFabricBootstrapGuide(workspaceRoot, options.force);
   for (const bootstrapTarget of targets) {
     details.push({
       client: bootstrapTarget.client,

package/dist/index.js

@@ -8,16 +8,17 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  init: () => import("./init-QC2MLFHR.js").then((module) => module.default),
-  update: () => import("./update-FY2WKWPB.js").then((module) => module.default),
-  scan: () => import("./scan-43R3IBLR.js").then((module) => module.default),
+  approve: () => import("./approve-YT4DEABS.js").then((module) => module.default),
+  init: () => import("./init-YR7EVBYQ.js").then((module) => module.default),
+  update: () => import("./update-M5M5PYKE.js").then((module) => module.default),
+  scan: () => import("./scan-QH76LC7Z.js").then((module) => module.default),
   serve: () => import("./serve-4J2CQY25.js").then((module) => module.default),
   doctor: () => import("./doctor-QTSG2RWF.js").then((module) => module.default),
   "sync-meta": () => import("./sync-meta-LKVSO6TS.js").then((module) => module.default),
   "human-lint": () => import("./human-lint-YSFOZHZ7.js").then((module) => module.default),
   "ledger-append": () => import("./ledger-append-DULKJ6Q2.js").then((module) => module.default),
   "pre-commit": () => import("./pre-commit-IK6SJOPT.js").then((module) => module.default),
-  bootstrap: () => import("./bootstrap-B6RCVJZJ.js").then((module) => module.default),
+  bootstrap: () => import("./bootstrap-VGL3AR26.js").then((module) => module.default),
   config: () => import("./config-EC5L2QNI.js").then((module) => module.configCmd),
   hooks: () => import("./hooks-ZSWVH2JD.js").then((module) => ({
     ...module.default,
@@ -32,7 +33,7 @@ var allCommands = {
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "1.4.0",
+    version: "1.5.0",
     description: 'Initialize and manage Fabric projects. Use "fabric init" for one-shot setup.'
   },
   subCommands: allCommands

package/dist/{init-QC2MLFHR.js → init-YR7EVBYQ.js}

@@ -2,19 +2,10 @@
 import {
   buildFabricBootstrapGuide,
   installBootstrap
-} from "./chunk-XQYY2U2C.js";
+} from "./chunk-T2WJF5I3.js";
 import {
   detectFramework
-} from "./chunk-AZRKMFRY.js";
-import {
-  installMcpClients
-} from "./chunk-BVTMVW5M.js";
-import {
-  detectClientSupports
-} from "./chunk-BEKSXO5N.js";
-import {
-  installHooks
-} from "./chunk-YDZJRLHL.js";
+} from "./chunk-QSAEGVKE.js";
 import {
   createDebugLogger,
   resolveDevMode
@@ -24,6 +15,15 @@ import {
   padEnd,
   paint
 } from "./chunk-WWNXR34K.js";
+import {
+  installMcpClients
+} from "./chunk-BVTMVW5M.js";
+import {
+  detectClientSupports
+} from "./chunk-BEKSXO5N.js";
+import {
+  installHooks
+} from "./chunk-YDZJRLHL.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -38,11 +38,14 @@ import { cancel, confirm, group, intro, isCancel, log, note, outro, select } fro
 import { defineCommand } from "citty";
 
 // src/scanner/forensic.ts
+import { execFileSync } from "child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { createRequire } from "module";
 import { basename, extname, isAbsolute, join, posix, relative, resolve, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
+var require2 = createRequire(import.meta.url);
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".fabric",
   ".git",
@@ -68,9 +71,48 @@ 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"],
+  react: ["package.json", "tsconfig.json"],
   next: ["package.json", "tsconfig.json"],
   vite: ["package.json", "tsconfig.json"]
 };
+var FRAMEWORK_IMPORT_PROFILES = {
+  "cocos-creator": {
+    pattern: "cocos-component-class",
+    family: "component",
+    statement: "Sampled entry files use Cocos Creator component classes.",
+    proposedRule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
+    alternatives: ["Generic TypeScript utility module"],
+    rationale: "Cocos framework imports and component markers co-occur in sampled entry files.",
+    packages: ["cc"]
+  },
+  react: {
+    pattern: "react-root",
+    family: "entry",
+    statement: "Sampled entry files import React framework packages.",
+    proposedRule: "Keep root rendering and component composition aligned with React entry conventions.",
+    alternatives: ["Server-rendered route module"],
+    rationale: "AST import declarations reference React packages rather than comments or strings.",
+    packages: ["react", "react-dom", "react/jsx-runtime", "react-dom/client"]
+  },
+  vite: {
+    pattern: "vite-main-entry",
+    family: "entry",
+    statement: "Sampled entry files use the conventional Vite main entrypoint.",
+    proposedRule: "Keep primary bootstrapping logic inside src/main.*.",
+    alternatives: ["Alternative bundler entrypoint"],
+    rationale: "Entry path and framework imports align with a Vite bootstrap surface.",
+    packages: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "vite", "react", "vue"]
+  },
+  next: {
+    pattern: "next-route-component",
+    family: "entry",
+    statement: "Sampled entry files align with Next.js route modules.",
+    proposedRule: "Preserve route-segment boundaries when editing app/ or pages/ files.",
+    alternatives: ["Generic source module"],
+    rationale: "Route placement and Next/React imports anchor these files to the request surface.",
+    packages: ["next", "next/link", "next/navigation", "react"]
+  }
+};
 var SAMPLE_LIMIT = 5;
 var SAMPLE_LINE_LIMIT = 30;
 var ENTRY_FAMILY_LIMIT = 1;
@@ -80,12 +122,17 @@ var DEFAULT_SAMPLING_BUDGET = {
   max_files: 15,
   max_lines_per_file: 100
 };
-function buildForensicReport(targetInput) {
+var treeSitterModulePromise = null;
+var parserInitPromise = null;
+var languagePromiseByKind = {};
+var parserBundlePromiseByKind = {};
+async 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 entryPoints = collectEntryPoints(target, topology.files);
+  const packageDependencies = readPackageDependencies(target);
+  const codeSamples = await buildCodeSamples(target, entryPoints, framework.kind, topology, packageDependencies);
   const assertions = buildAssertions(framework.kind, topology, codeSamples);
   const candidateFiles = buildCandidateFiles(topology, codeSamples, entryPoints);
   const readme = readReadmeInfo(target);
@@ -180,7 +227,7 @@ function isKeyDirectory(relativePath) {
   const name = basename(relativePath);
   return KEY_DIRECTORY_NAMES.has(name);
 }
-function collectEntryPoints(files) {
+function collectEntryPoints(target, files) {
   const entryPoints = [];
   for (const file of files) {
     const reason = getEntryPointReason(file.relativePath);
@@ -193,7 +240,9 @@ function collectEntryPoints(files) {
       size_bytes: file.sizeBytes
     });
   }
-  return entryPoints;
+  return entryPoints.sort(
+    (left, right) => compareCandidateScore(readGitChurnWeight(target, right.path), readGitChurnWeight(target, left.path))
+  );
 }
 function getEntryPointReason(relativePath) {
   if (!SCRIPT_EXTENSIONS.has(extname(relativePath))) {
@@ -216,20 +265,26 @@ function getEntryPointReason(relativePath) {
   }
   return null;
 }
-function buildCodeSamples(target, entryPoints) {
-  return entryPoints.slice(0, SAMPLE_LIMIT).map((entryPoint) => {
+async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
+  const samples = [];
+  for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
     const absolutePath = join(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
-    const patternAnalysis = inferPatternHint(entryPoint.path, sample.snippet);
-    return {
+    const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
+      frameworkKind,
+      topology,
+      packageDependencies
+    });
+    samples.push({
       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)
-    };
-  });
+    });
+  }
+  return samples;
 }
 function readFirstLines(path, lineLimit) {
   try {
@@ -249,7 +304,100 @@ function readFirstLines(path, lineLimit) {
     };
   }
 }
-function inferPatternHint(relativePath, snippet) {
+function readPackageDependencies(target) {
+  const packageJsonPath = join(target, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return new Map([
+      ...Object.entries(packageJson.dependencies ?? {}),
+      ...Object.entries(packageJson.devDependencies ?? {}),
+      ...Object.entries(packageJson.peerDependencies ?? {}),
+      ...Object.entries(packageJson.optionalDependencies ?? {})
+    ]);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function readGitChurnWeight(target, relativePath) {
+  try {
+    const output = execFileSync("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
+      cwd: target,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    });
+    return output.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+async function inferPatternHint(relativePath, snippet, options = {}) {
+  const input = {
+    relativePath,
+    snippet,
+    frameworkKind: options.frameworkKind ?? "unknown",
+    topology: options.topology ?? createEmptyTopology(),
+    packageDependencies: options.packageDependencies ?? /* @__PURE__ */ new Map()
+  };
+  const importAnalysis = await analyzeImports(input.relativePath, input.snippet);
+  if (importAnalysis.astLevel) {
+    const astResult = buildAstPatternHint(input, importAnalysis.imports);
+    if (astResult !== null) {
+      return astResult;
+    }
+  }
+  return inferTextPatternHint(input.relativePath, input.snippet);
+}
+function createEmptyTopology() {
+  return {
+    total_files: 0,
+    by_ext: {},
+    key_dirs: [],
+    max_depth: 0,
+    files: []
+  };
+}
+function buildAstPatternHint(input, imports) {
+  const profile = resolveFrameworkImportProfile(input.frameworkKind, input.relativePath, imports);
+  if (profile === null) {
+    return null;
+  }
+  const matchingImports = imports.filter((source) => matchesAnyFrameworkPackage(source, profile.packages));
+  const configFiles = getExpectedConfigFiles(input.frameworkKind).filter((file) => hasFile(input.topology.files, file));
+  const packageMatches = profile.packages.filter((packageName) => input.packageDependencies.has(packageName));
+  const coOccurring = compactPatternNames([
+    ...matchingImports.map((source) => `import:${source}`),
+    ...configFiles.map(normalizeConfigPattern),
+    ...packageMatches.map((packageName) => `package:${packageName}`),
+    input.relativePath.startsWith("app/") ? "app-router" : null,
+    input.relativePath.startsWith("pages/") ? "pages-router" : null,
+    input.relativePath === "src/main.ts" || input.relativePath === "src/main.js" ? "main-entry" : null,
+    input.snippet.includes("@ccclass(") ? "ccclass-decorator" : null,
+    input.snippet.includes("extends Component") ? "component-base" : null
+  ]);
+  return {
+    pattern: profile.pattern,
+    type: "pattern",
+    confidence: scoreFrameworkConfidence({
+      importCount: matchingImports.length,
+      configCount: configFiles.length,
+      packageCount: packageMatches.length,
+      astLevel: true
+    }),
+    evidence_lines: matchingImports.length > 0 ? matchingImports : imports.slice(0, 3),
+    co_occurring: coOccurring,
+    family: profile.family,
+    ast_level: true,
+    statement: profile.statement,
+    proposed_rule: profile.proposedRule,
+    alternatives: profile.alternatives,
+    rationale: profile.rationale
+  };
+}
+function inferTextPatternHint(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,
@@ -257,11 +405,16 @@ function inferPatternHint(relativePath, snippet) {
     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),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: cocosCoOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         snippet.includes("_decorator") ? "_decorator" : null,
         snippet.includes("@ccclass(") ? "@ccclass(" : null,
@@ -269,7 +422,7 @@ function inferPatternHint(relativePath, snippet) {
       ]),
       co_occurring: cocosCoOccurring,
       family: "component",
-      ast_level: astLevel,
+      ast_level: false,
       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"],
@@ -285,7 +438,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "react-root",
       type: "pattern",
-      confidence: determineConfidence(1, reactCoOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: reactCoOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         snippet.includes("createRoot(") ? "createRoot(" : null,
         snippet.includes("ReactDOM.render(") ? "ReactDOM.render(" : null
@@ -308,7 +467,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "next-route-component",
       type: "pattern",
-      confidence: determineConfidence(1, coOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: coOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         relativePath.startsWith("app/") ? "app/" : null,
         relativePath.startsWith("pages/") ? "pages/" : null
@@ -331,7 +496,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "vite-main-entry",
       type: "pattern",
-      confidence: determineConfidence(1, coOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: coOccurring.length
+      }),
       evidence_lines: ["src/main"],
       co_occurring: coOccurring,
       family: "entry",
@@ -355,6 +526,125 @@ function inferPatternHint(relativePath, snippet) {
     rationale: "No strong framework markers were detected in the sampled snippet."
   };
 }
+async function analyzeImports(relativePath, snippet) {
+  if (snippet.trim().length === 0) {
+    return { imports: [], astLevel: false };
+  }
+  try {
+    const imports = await extractImports(snippet, getLanguageKindForPath(relativePath));
+    return { imports, astLevel: true };
+  } catch {
+    return { imports: [], astLevel: false };
+  }
+}
+async function extractImports(source, languageKind) {
+  const { parser } = await loadTreeSitter(languageKind);
+  let tree = null;
+  try {
+    tree = parser.parse(source);
+    if (tree === null || tree.rootNode.hasError) {
+      throw new Error("tree-sitter parse failed");
+    }
+    const imports = [];
+    collectImportSources(tree.rootNode, imports);
+    return compactPatternNames(imports);
+  } finally {
+    tree?.delete();
+  }
+}
+async function loadTreeSitter(languageKind) {
+  parserBundlePromiseByKind[languageKind] ??= createTreeSitterParserBundle(languageKind);
+  return parserBundlePromiseByKind[languageKind];
+}
+async function createTreeSitterParserBundle(languageKind) {
+  const treeSitter = await loadTreeSitterModule();
+  await initTreeSitterParser(treeSitter);
+  const language = await loadTreeSitterLanguage(treeSitter, languageKind);
+  const parser = new treeSitter.Parser();
+  parser.setLanguage(language);
+  return { parser, language };
+}
+function loadTreeSitterModule() {
+  treeSitterModulePromise ??= import("web-tree-sitter");
+  return treeSitterModulePromise;
+}
+function initTreeSitterParser(treeSitter) {
+  parserInitPromise ??= treeSitter.Parser.init({
+    locateFile: (scriptName) => scriptName.endsWith(".wasm") ? require2.resolve("web-tree-sitter/web-tree-sitter.wasm") : scriptName
+  });
+  return parserInitPromise;
+}
+function loadTreeSitterLanguage(treeSitter, languageKind) {
+  languagePromiseByKind[languageKind] ??= treeSitter.Language.load(resolveTreeSitterGrammarPath(languageKind));
+  return languagePromiseByKind[languageKind];
+}
+function resolveTreeSitterGrammarPath(languageKind) {
+  switch (languageKind) {
+    case "typescript":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
+    case "tsx":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+    case "javascript":
+      return require2.resolve("tree-sitter-javascript/tree-sitter-javascript.wasm");
+  }
+}
+function getLanguageKindForPath(relativePath) {
+  const extension = extname(relativePath);
+  if (extension === ".tsx") {
+    return "tsx";
+  }
+  if (extension === ".ts") {
+    return "typescript";
+  }
+  return "javascript";
+}
+function collectImportSources(node, imports) {
+  if (node.type === "import_statement" || node.type === "import_declaration") {
+    const sourceNode = node.childForFieldName("source");
+    if (sourceNode !== null) {
+      const source = stripStringLiteral(sourceNode.text);
+      if (source.length > 0) {
+        imports.push(source);
+      }
+    }
+  }
+  for (let index = 0; index < node.namedChildCount; index += 1) {
+    const child = node.namedChild(index);
+    if (child !== null) {
+      collectImportSources(child, imports);
+    }
+  }
+}
+function stripStringLiteral(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function resolveFrameworkImportProfile(frameworkKind, relativePath, imports) {
+  const primaryProfile = FRAMEWORK_IMPORT_PROFILES[frameworkKind];
+  if (primaryProfile !== void 0 && imports.some((source) => matchesAnyFrameworkPackage(source, primaryProfile.packages))) {
+    return primaryProfile;
+  }
+  if ((relativePath.startsWith("app/") || relativePath.startsWith("pages/")) && FRAMEWORK_IMPORT_PROFILES.next !== void 0) {
+    return FRAMEWORK_IMPORT_PROFILES.next;
+  }
+  return Object.values(FRAMEWORK_IMPORT_PROFILES).find(
+    (profile) => imports.some((source) => matchesAnyFrameworkPackage(source, profile.packages))
+  ) ?? null;
+}
+function matchesAnyFrameworkPackage(source, packageNames) {
+  return packageNames.some((packageName) => source === packageName || source.startsWith(`${packageName}/`));
+}
+function scoreFrameworkConfidence(input) {
+  if (!input.astLevel) {
+    return (input.keywordCount ?? 0) > 0 ? "MEDIUM" : "LOW";
+  }
+  if (input.importCount > 3) {
+    return "HIGH";
+  }
+  if (input.importCount >= 1 && input.importCount <= 3) {
+    return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "MEDIUM";
+  }
+  return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
+}
 function readReadmeInfo(target) {
   const readmePath = join(target, "README.md");
   const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
@@ -857,7 +1147,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.4.0" : "unknown";
+  return true ? "1.5.0" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -962,7 +1252,7 @@ async function runInitCommand(args) {
     writeStderr(t("cli.init.compat.legacy-stage-flags"));
   }
   const supports = detectClientSupports(intent.target);
-  const basePlan = buildInitExecutionPlan({
+  const basePlan = await buildInitExecutionPlan({
     target: intent.target,
     options: intent.options,
     mcpInstallMode: intent.mcpInstallMode,
@@ -998,9 +1288,9 @@ function resolveInitCliIntent(args, targetInput) {
     wizardEnabled: shouldUseInitWizard(args, terminalInteractive) && !planOnly
   };
 }
-function buildInitExecutionPlan(input) {
+async function buildInitExecutionPlan(input) {
   const options = input.options ?? {};
-  const scaffold = buildInitFabricPlan(input.target, options);
+  const scaffold = await buildInitFabricPlan(input.target, options);
   const supports = input.supports ?? detectClientSupports(input.target);
   const mcpInstallMode = input.mcpInstallMode ?? "global";
   const stages = [
@@ -1080,7 +1370,7 @@ async function executeInitExecutionPlan(plan) {
     finalSupports
   };
 }
-function buildInitFabricPlan(target, options) {
+async function buildInitFabricPlan(target, options) {
   assertExistingDirectory2(target);
   const fabricDir = join2(target, ".fabric");
   const bootstrapPath = join2(fabricDir, "bootstrap", "README.md");
@@ -1099,9 +1389,9 @@ function buildInitFabricPlan(target, options) {
   const metaAction = planFreshPath(metaPath, options);
   const humanLockAction = planFreshPath(humanLockPath, options);
   const forensicAction = planFreshPath(forensicPath, options);
-  const forensicReport = buildForensicReport(target);
+  const forensicReport = await buildForensicReport(target);
   const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
-  const bootstrapContent = buildFabricBootstrapGuide(target);
+  const bootstrapContent = await buildFabricBootstrapGuide(target);
   const bootstrapHash = sha256(bootstrapContent);
   const meta = createInitialMeta(bootstrapHash);
   return {
@@ -1194,8 +1484,8 @@ function executeInitFabricPlan(plan) {
     claudeSettingsAction: plan.claudeSettings.action
   };
 }
-function initFabric(target, options) {
-  return executeInitFabricPlan(buildInitFabricPlan(target, options));
+async function initFabric(target, options) {
+  return executeInitFabricPlan(await buildInitFabricPlan(target, options));
 }
 function shouldUseInitWizard(args, terminalInteractive = isInteractiveInit()) {
   return terminalInteractive && args.interactive !== false && args.yes !== true;

package/dist/{scan-43R3IBLR.js → scan-QH76LC7Z.js}

@@ -3,7 +3,7 @@ import {
   createScanReport,
   scanCommand,
   scan_default
-} from "./chunk-AZRKMFRY.js";
+} from "./chunk-QSAEGVKE.js";
 import "./chunk-AEOYCVBG.js";
 import "./chunk-WWNXR34K.js";
 import "./chunk-6ICJICVU.js";

package/dist/scanner/tree-sitter-probe.d.ts

@@ -0,0 +1,24 @@
+type TreeSitterProbeResult = {
+    ok: boolean;
+    node_version: string;
+    package_engines: "not-declared";
+    root_node_type: string;
+    has_error: boolean;
+    elapsed_ms: number;
+    wasm: {
+        runtime_path: string;
+        runtime_bytes: number;
+        javascript_grammar_path: string;
+        javascript_grammar_bytes: number;
+    };
+    decision: {
+        status: "feasible";
+        loading_strategy: "lazy";
+        bundle_size_impact: string;
+        grammar_strategy: string;
+        integration_note: string;
+    };
+};
+declare function runTreeSitterProbe(source?: string): Promise<TreeSitterProbeResult>;
+
+export { type TreeSitterProbeResult, runTreeSitterProbe };

package/dist/scanner/tree-sitter-probe.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+// src/scanner/tree-sitter-probe.ts
+import { realpathSync, statSync } from "fs";
+import { createRequire } from "module";
+import { resolve } from "path";
+import { performance } from "perf_hooks";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var PROBE_SOURCE = `import { strict as assert } from "node:assert";
+
+const users = [{ id: "1", name: "Ada" }];
+
+export function findUser(id) {
+  return users.find((user) => user.id === id);
+}
+
+assert.equal(findUser("1")?.name, "Ada");
+console.log("parsed");`;
+var treeSitterModulePromise = null;
+var parserInitPromise = null;
+var javascriptLanguagePromise = null;
+async function runTreeSitterProbe(source = PROBE_SOURCE) {
+  const startedAt = performance.now();
+  const assets = resolveTreeSitterAssets();
+  const treeSitter = await loadTreeSitterModule();
+  await initParser(treeSitter, assets.runtimeWasmPath);
+  const language = await loadJavaScriptLanguage(treeSitter, assets.javascriptGrammarPath);
+  const parser = new treeSitter.Parser();
+  const runtimeBytes = statSync(assets.runtimeWasmPath).size;
+  const javascriptGrammarBytes = statSync(assets.javascriptGrammarPath).size;
+  let tree = null;
+  try {
+    parser.setLanguage(language);
+    tree = parser.parse(source);
+    if (tree === null) {
+      throw new Error("web-tree-sitter probe failed: parser returned null syntax tree");
+    }
+    const rootNode = tree.rootNode;
+    return {
+      ok: !rootNode.hasError,
+      node_version: process.version,
+      package_engines: "not-declared",
+      root_node_type: rootNode.type,
+      has_error: rootNode.hasError,
+      elapsed_ms: Math.round(performance.now() - startedAt),
+      wasm: {
+        runtime_path: assets.runtimeWasmPath,
+        runtime_bytes: runtimeBytes,
+        javascript_grammar_path: assets.javascriptGrammarPath,
+        javascript_grammar_bytes: javascriptGrammarBytes
+      },
+      decision: {
+        status: "feasible",
+        loading_strategy: "lazy",
+        bundle_size_impact: formatBundleImpact(runtimeBytes, javascriptGrammarBytes),
+        grammar_strategy: "Use tree-sitter-javascript WASM for JavaScript and TS-compatible syntax; evaluate tree-sitter-typescript before parsing TypeScript-only syntax.",
+        integration_note: "Keep web-tree-sitter behind a dynamic import at the forensic inferPatternHint() call site to avoid CLI startup cost."
+      }
+    };
+  } finally {
+    tree?.delete();
+    parser.delete();
+  }
+}
+function resolveTreeSitterAssets() {
+  return {
+    runtimeWasmPath: require2.resolve("web-tree-sitter/web-tree-sitter.wasm"),
+    javascriptGrammarPath: require2.resolve("tree-sitter-javascript/tree-sitter-javascript.wasm")
+  };
+}
+function loadTreeSitterModule() {
+  treeSitterModulePromise ??= import("web-tree-sitter");
+  return treeSitterModulePromise;
+}
+function initParser(treeSitter, runtimeWasmPath) {
+  parserInitPromise ??= treeSitter.Parser.init({
+    locateFile: (scriptName) => scriptName.endsWith(".wasm") ? runtimeWasmPath : scriptName
+  });
+  return parserInitPromise;
+}
+function loadJavaScriptLanguage(treeSitter, javascriptGrammarPath) {
+  javascriptLanguagePromise ??= treeSitter.Language.load(javascriptGrammarPath);
+  return javascriptLanguagePromise;
+}
+function formatBundleImpact(runtimeBytes, javascriptGrammarBytes) {
+  const combinedBytes = runtimeBytes + javascriptGrammarBytes;
+  return `${formatBytes(combinedBytes)} combined WASM payload (${formatBytes(runtimeBytes)} runtime + ${formatBytes(javascriptGrammarBytes)} JavaScript grammar); package unpacked sizes are larger and acceptable only with lazy loading.`;
+}
+function formatBytes(bytes) {
+  return `${(bytes / 1024).toFixed(1)}KB`;
+}
+var entrypoint = process.argv[1];
+var currentFilePath = fileURLToPath(import.meta.url);
+var isMainModule = entrypoint !== void 0 && realpathSync(resolve(entrypoint)) === currentFilePath;
+if (isMainModule) {
+  runTreeSitterProbe().then((result) => {
+    console.log(JSON.stringify(result, null, 2));
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`web-tree-sitter probe failed: ${message}`);
+    process.exitCode = 1;
+  });
+}
+export {
+  runTreeSitterProbe
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "type": "module",
   "bin": {
     "fab": "dist/index.js",
@@ -19,8 +19,11 @@
     "minimatch": "^10.0.1",
     "picocolors": "^1.1.1",
     "string-width": "^7.2.0",
-    "@fenglimg/fabric-server": "1.4.0",
-    "@fenglimg/fabric-shared": "1.4.0"
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "web-tree-sitter": "^0.26.8",
+    "@fenglimg/fabric-server": "1.5.0",
+    "@fenglimg/fabric-shared": "1.5.0"
   },
   "devDependencies": {
     "@types/iarna__toml": "^2.0.5",

package/dist/{update-FY2WKWPB.js → update-M5M5PYKE.js}

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  resolveDevModeTarget
+} from "./chunk-AEOYCVBG.js";
+import {
+  paint
+} from "./chunk-WWNXR34K.js";
 import {
   installMcpClients
 } from "./chunk-BVTMVW5M.js";
@@ -6,12 +12,6 @@ import "./chunk-BEKSXO5N.js";
 import {
   installHooks
 } from "./chunk-YDZJRLHL.js";
-import {
-  resolveDevModeTarget
-} from "./chunk-AEOYCVBG.js";
-import {
-  paint
-} from "./chunk-WWNXR34K.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";