@fenglimg/fabric-cli 2.0.0 → 2.0.1

package/dist/metrics-ACEQFPDU.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+// src/commands/metrics.ts
+import { resolve } from "path";
+import { defineCommand } from "citty";
+import { readMetrics } from "@fenglimg/fabric-server";
+function parseSinceArg(raw) {
+  if (raw === void 0 || raw.length === 0) return 0;
+  const match = /^(\d+)([smhd]?)$/u.exec(raw);
+  if (match === null) {
+    throw new Error(`--since: invalid duration "${raw}" (expected e.g. 24h, 7d, 30m)`);
+  }
+  const n = Number.parseInt(match[1], 10);
+  const unit = match[2] ?? "s";
+  const multipliers = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return n * (multipliers[unit] ?? 1e3);
+}
+function aggregate(rows, sinceMs, now) {
+  const cutoff = sinceMs > 0 ? now.getTime() - sinceMs : 0;
+  const filtered = rows.filter((r) => {
+    if (cutoff === 0) return true;
+    const ts = Date.parse(r.timestamp);
+    return Number.isFinite(ts) && ts >= cutoff;
+  });
+  const totals = {};
+  const perEntryConsumed = {};
+  for (const row of filtered) {
+    for (const [name, count] of Object.entries(row.counters)) {
+      if (name.startsWith("knowledge_consumed:")) {
+        const id = name.slice("knowledge_consumed:".length);
+        perEntryConsumed[id] = (perEntryConsumed[id] ?? 0) + count;
+        totals["knowledge_consumed"] = (totals["knowledge_consumed"] ?? 0) + count;
+        continue;
+      }
+      totals[name] = (totals[name] ?? 0) + count;
+    }
+  }
+  return {
+    windowDescription: sinceMs > 0 ? formatDuration(sinceMs) : "all-time",
+    rowCount: filtered.length,
+    totals,
+    perEntryConsumed,
+    rangeStart: filtered[0]?.timestamp ?? null,
+    rangeEnd: filtered[filtered.length - 1]?.timestamp ?? null
+  };
+}
+function formatDuration(ms) {
+  if (ms >= 864e5) return `${Math.round(ms / 864e5)}d`;
+  if (ms >= 36e5) return `${Math.round(ms / 36e5)}h`;
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function renderText(agg) {
+  const lines = [];
+  lines.push(`Fabric metrics \u2014 window: ${agg.windowDescription}`);
+  if (agg.rangeStart && agg.rangeEnd) {
+    lines.push(`  rows: ${agg.rowCount} (${agg.rangeStart} \u2192 ${agg.rangeEnd})`);
+  } else {
+    lines.push(`  rows: ${agg.rowCount}`);
+  }
+  lines.push("");
+  if (Object.keys(agg.totals).length === 0) {
+    lines.push("  (no counter activity in window \u2014 server may be idle or just started)");
+    return lines.join("\n");
+  }
+  lines.push("  counter                              total");
+  lines.push("  ------------------------------------ ----------");
+  const sorted = Object.entries(agg.totals).sort((a, b) => b[1] - a[1]);
+  for (const [name, count] of sorted) {
+    lines.push(`  ${name.padEnd(36)} ${String(count).padStart(10)}`);
+  }
+  const perEntrySorted = Object.entries(agg.perEntryConsumed).sort((a, b) => b[1] - a[1]).slice(0, 10);
+  if (perEntrySorted.length > 0) {
+    lines.push("");
+    lines.push("  Top per-entry consumed (knowledge_consumed:<id>)");
+    lines.push("  ------------------------------------ ----------");
+    for (const [id, count] of perEntrySorted) {
+      lines.push(`  ${id.padEnd(36)} ${String(count).padStart(10)}`);
+    }
+  }
+  return lines.join("\n");
+}
+var metricsCommand = defineCommand({
+  meta: {
+    name: "metrics",
+    description: "Print a text dashboard of Fabric counter activity from .fabric/metrics.jsonl",
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON instead of the text table.",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Project root (defaults to the current working directory)."
+    },
+    since: {
+      type: "string",
+      description: "Limit to rows within a recent window. Examples: 24h, 7d, 30m, 90s. Omit for all-time."
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolve(args.target ?? process.cwd());
+    const sinceMs = parseSinceArg(args.since);
+    const rows = await readMetrics(projectRoot);
+    const aggregated = aggregate(rows, sinceMs, /* @__PURE__ */ new Date());
+    if (args.json === true) {
+      process.stdout.write(`${JSON.stringify(aggregated)}
+`);
+    } else {
+      process.stdout.write(`${renderText(aggregated)}
+`);
+    }
+  }
+});
+var metrics_default = metricsCommand;
+export {
+  metrics_default as default,
+  metricsCommand
+};

package/dist/onboard-coverage-MFCAEBDO.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-PWLW3B57.js";
+
+// src/commands/onboard-coverage.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { defineCommand } from "citty";
+import {
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL
+} from "@fenglimg/fabric-shared";
+var KNOWLEDGE_TYPE_DIRS = [
+  "decisions",
+  "pitfalls",
+  "guidelines",
+  "models",
+  "processes"
+];
+var FABRIC_CONFIG_PATH = [".fabric", "fabric-config.json"];
+function emptyFilled() {
+  const filled = {};
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot] = [];
+  }
+  return filled;
+}
+function readOnboardSlotFrontmatter(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return void 0;
+  const block = match[1];
+  if (block === void 0) return void 0;
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim();
+    if (key !== "onboard_slot") continue;
+    let value = line.slice(sep + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return void 0;
+}
+function readStableIdFrontmatter(filePath, fallbackName) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return fallbackName.replace(/\.md$/u, "");
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return fallbackName.replace(/\.md$/u, "");
+  const block = match[1];
+  if (block === void 0) return fallbackName.replace(/\.md$/u, "");
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    if (line.slice(0, sep).trim() !== "id") continue;
+    return line.slice(sep + 1).trim();
+  }
+  return fallbackName.replace(/\.md$/u, "");
+}
+function readOptedOutSlots(projectRoot) {
+  const path = join(projectRoot, ...FABRIC_CONFIG_PATH);
+  if (!existsSync(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(
+      `onboard-coverage: ignoring malformed fabric-config.json (${err instanceof Error ? err.message : String(err)})
+`
+    );
+    return [];
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [];
+  }
+  const slots = parsed.onboard_slots_opted_out;
+  if (!Array.isArray(slots)) return [];
+  return slots.filter((v) => typeof v === "string");
+}
+function runOnboardCoverage(projectRoot) {
+  const filled = emptyFilled();
+  const knowledgeRoot = join(projectRoot, ".fabric", "knowledge");
+  if (existsSync(knowledgeRoot)) {
+    for (const typeDir of KNOWLEDGE_TYPE_DIRS) {
+      const dir = join(knowledgeRoot, typeDir);
+      if (!existsSync(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.endsWith(".md")) continue;
+        const filePath = join(dir, entry.name);
+        const slot = readOnboardSlotFrontmatter(filePath);
+        if (slot === void 0) continue;
+        if (!ONBOARD_SLOT_NAMES.includes(slot)) continue;
+        const stableId = readStableIdFrontmatter(filePath, entry.name);
+        filled[slot].push(stableId);
+      }
+    }
+  }
+  const optedOut = readOptedOutSlots(projectRoot);
+  const missing = ONBOARD_SLOT_NAMES.filter((slot) => {
+    if (filled[slot].length > 0) return false;
+    if (optedOut.includes(slot)) return false;
+    return true;
+  });
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot].sort();
+  }
+  return {
+    filled,
+    missing,
+    opted_out: optedOut,
+    total: ONBOARD_SLOT_TOTAL
+  };
+}
+function renderHumanReadable(report) {
+  const filledCount = ONBOARD_SLOT_NAMES.filter(
+    (slot) => report.filled[slot].length > 0
+  ).length;
+  const optedOutCount = report.opted_out.length;
+  const missingCount = report.missing.length;
+  const lines = [];
+  lines.push(
+    `Onboard coverage: ${filledCount}/${report.total} filled, ${optedOutCount} opted-out, ${missingCount} missing`
+  );
+  lines.push("");
+  lines.push("  slot                       status      entries");
+  lines.push("  -------------------------- ----------- -------------------------");
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    const entries = report.filled[slot];
+    let status;
+    let detail;
+    if (entries.length > 0) {
+      status = "filled";
+      detail = entries.join(", ");
+    } else if (report.opted_out.includes(slot)) {
+      status = "opted-out";
+      detail = "(user-dismissed; run `fabric config onboard-reset` to re-open)";
+    } else {
+      status = "missing";
+      detail = "(run /fabric-archive to onboard)";
+    }
+    lines.push(`  ${slot.padEnd(26)} ${status.padEnd(11)} ${detail}`);
+  }
+  return lines.join("\n");
+}
+var onboardCoverageCommand = defineCommand({
+  meta: {
+    name: "onboard-coverage",
+    // v2.0.0-rc.29 TASK-008 (BUG-L2): route description strings through t()
+    // (mirrors serve.ts pattern). Previously this command was English-only
+    // even when the rest of `fabric --help` rendered zh-CN, so Chinese-locale
+    // users saw an isolated English block under --help.
+    description: t("cli.onboard-coverage.description"),
+    // Mirrors `plan-context-hint`: hidden from `fabric --help` so the top-level
+    // banner stays focused on install/doctor/serve/config. The command stays
+    // callable directly from Skills via `fabric onboard-coverage --json`.
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: t("cli.onboard-coverage.args.json.description"),
+      default: false
+    },
+    target: {
+      type: "string",
+      description: t("cli.onboard-coverage.args.target.description")
+    }
+  },
+  async run({ args }) {
+    try {
+      const projectRoot = resolve(args.target ?? process.cwd());
+      const report = runOnboardCoverage(projectRoot);
+      if (args.json === true) {
+        process.stdout.write(`${JSON.stringify(report)}
+`);
+      } else {
+        process.stdout.write(`${renderHumanReadable(report)}
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`onboard-coverage failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
+var onboard_coverage_default = onboardCoverageCommand;
+export {
+  onboard_coverage_default as default,
+  onboardCoverageCommand,
+  runOnboardCoverage
+};

package/dist/{plan-context-hint-QMUPAXIB.js → plan-context-hint-FC6P3WFE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-COI5VDFU.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
@@ -10,7 +10,12 @@ var ALL_PATHS_SENTINEL = "**";
 var planContextHintCommand = defineCommand({
   meta: {
     name: "plan-context-hint",
-    description: "Emit versioned knowledge hint JSON to stdout. Used by rc.6 hooks and the fabric-import skill."
+    description: "Emit versioned knowledge hint JSON to stdout. Used by rc.6 hooks and the fabric-import skill.",
+    // rc.15 TASK-004 (C8): hidden from `fabric --help` listing. The command stays
+    // callable so hook scripts and the fabric-import skill can still invoke
+    // it via `fabric plan-context-hint ...`; it just no longer appears in the
+    // top-level usage banner alongside install/doctor/serve/uninstall/config.
+    hidden: true
   },
   args: {
     paths: {
@@ -53,27 +58,38 @@ async function runPlanContextHint(opts) {
   const result = await planContext(resolution.target, {
     paths: targetPaths
   });
-  const sharedIndex = result.shared.description_index;
-  const narrowSource = all ? sharedIndex : (
-    // Path mode: union of per-entry description_index across requested
-    // paths, deduped by stable_id. This is identical to `shared` for L0/L1
-    // entries (always included) and additionally captures L2 entries whose
-    // scope_glob matches the requested path.
-    dedupeByStableId(result.entries.flatMap((entry) => entry.description_index))
-  );
-  const narrow = narrowSource.map((item) => ({
+  const candidates = result.candidates;
+  const entries = candidates.map((item) => ({
     id: item.stable_id,
-    type: item.type ?? item.description.knowledge_type ?? "",
-    maturity: item.maturity ?? item.description.maturity ?? "",
-    summary: item.description.summary
+    type: item.description.knowledge_type ?? "",
+    maturity: item.description.maturity ?? "",
+    summary: item.description.summary,
+    relevance_scope: item.description.relevance_scope ?? "broad"
   }));
-  return {
-    version: 1,
+  let narrow_count = 0;
+  let broad_only_count = 0;
+  for (const e of entries) {
+    if (e.relevance_scope === "narrow") narrow_count += 1;
+    else broad_only_count += 1;
+  }
+  const output = {
+    version: 2,
     revision_hash: result.revision_hash,
     target_paths: targetPaths,
-    narrow,
-    broad_count: sharedIndex.length
+    entries,
+    // Legacy field — preserved for v2 consumers that haven't migrated. Value
+    // semantics unchanged from rc.18 (total candidate count).
+    broad_count: candidates.length,
+    narrow_count,
+    broad_only_count
   };
+  if (result.auto_healed === true) {
+    output.auto_healed = true;
+    if (typeof result.previous_revision_hash === "string") {
+      output.previous_revision_hash = result.previous_revision_hash;
+    }
+  }
+  return output;
 }
 function parsePathsArg(raw) {
   if (raw === void 0 || raw.length === 0) {
@@ -81,16 +97,6 @@ function parsePathsArg(raw) {
   }
   return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
-function dedupeByStableId(items) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const item of items) {
-    if (seen.has(item.stable_id)) continue;
-    seen.add(item.stable_id);
-    result.push(item);
-  }
-  return result;
-}
 export {
   plan_context_hint_default as default,
   planContextHintCommand,