@fenglimg/fabric-cli 0.1.0

package/dist/bootstrap-5JAUC3JW.js

@@ -0,0 +1,195 @@
+import {
+  resolveClients
+} from "./chunk-LHPBYOF5.js";
+import {
+  readFabricConfig
+} from "./chunk-JLIIQ75E.js";
+
+// src/commands/bootstrap.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+var CLIENT_ALIASES = {
+  claude: "claude",
+  "claude-code": "claude",
+  claudecode: "claude",
+  claudecli: "claude",
+  claudecodecli: "claude",
+  claudedesktop: "claude",
+  claudecodedesktop: "claude",
+  cursor: "cursor",
+  windsurf: "windsurf",
+  roo: "roo",
+  "roo-code": "roo",
+  roocode: "roo",
+  gemini: "gemini",
+  "gemini-cli": "gemini",
+  geminicli: "gemini",
+  codex: "codex",
+  "codex-cli": "codex",
+  codexcli: "codex"
+};
+var CLIENT_TEMPLATE_MAP = {
+  claude: "templates/bootstrap/CLAUDE.md",
+  cursor: "templates/bootstrap/cursor-fabric-bootstrap.mdc",
+  windsurf: "templates/bootstrap/windsurf-fabric.md",
+  roo: "templates/bootstrap/roo-fabric.md",
+  gemini: "templates/bootstrap/GEMINI.md",
+  codex: "templates/bootstrap/codex-AGENTS-header.md"
+};
+var CLIENT_TARGET_MAP = {
+  claude: "CLAUDE.md",
+  cursor: ".cursor/rules/fabric-bootstrap.mdc",
+  windsurf: ".windsurf/rules/fabric.md",
+  roo: ".roo/rules/fabric.md",
+  gemini: "GEMINI.md",
+  codex: "AGENTS.md"
+};
+var bootstrapCommand = defineCommand({
+  meta: {
+    name: "bootstrap",
+    description: "Install Fabric bootstrap prompt templates for supported AI clients."
+  },
+  subCommands: {
+    install: defineCommand({
+      meta: {
+        name: "install",
+        description: "Copy Fabric bootstrap templates into client-native locations."
+      },
+      args: {
+        clients: {
+          type: "string",
+          description: "Optional comma-separated client filter, e.g. claude,cursor,codex."
+        }
+      },
+      async run({ args }) {
+        const workspaceRoot = process.cwd();
+        const selectedClients = parseClientFilter(args.clients);
+        const fabricConfig = readFabricConfig(workspaceRoot);
+        const detectedClients = detectBootstrapClients(workspaceRoot, fabricConfig);
+        const clients = selectedClients ?? detectedClients;
+        if (clients.size === 0) {
+          process.stderr.write(
+            "No bootstrap targets detected. Pass --clients claude,cursor,windsurf,roo,gemini,codex to install explicitly.\n"
+          );
+          return;
+        }
+        for (const client of clients) {
+          installBootstrap(client, workspaceRoot);
+        }
+      }
+    })
+  }
+});
+var bootstrap_default = bootstrapCommand;
+function parseClientFilter(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return null;
+  }
+  const clients = /* @__PURE__ */ new Set();
+  for (const rawClient of value.split(",")) {
+    const alias = rawClient.trim().toLowerCase();
+    const client = CLIENT_ALIASES[alias];
+    if (client === void 0) {
+      throw new Error(`Unknown client "${rawClient}". Use a comma-separated list such as claude,cursor,codex.`);
+    }
+    clients.add(client);
+  }
+  return clients;
+}
+function detectBootstrapClients(workspaceRoot, fabricConfig) {
+  const clients = /* @__PURE__ */ new Set();
+  for (const writer of resolveClients(workspaceRoot, fabricConfig)) {
+    const bootstrapClient = mapClientKind(writer.clientKind);
+    if (bootstrapClient !== null) {
+      clients.add(bootstrapClient);
+    }
+  }
+  return clients;
+}
+function mapClientKind(clientKind) {
+  switch (clientKind) {
+    case "ClaudeCodeCLI":
+    case "ClaudeCodeDesktop":
+      return "claude";
+    case "Cursor":
+      return "cursor";
+    case "Windsurf":
+      return "windsurf";
+    case "RooCode":
+      return "roo";
+    case "GeminiCLI":
+      return "gemini";
+    case "CodexCLI":
+      return "codex";
+    default:
+      return null;
+  }
+}
+function installBootstrap(client, workspaceRoot) {
+  const targetPath = resolve(workspaceRoot, CLIENT_TARGET_MAP[client]);
+  const templatePath = findTemplatePath(CLIENT_TEMPLATE_MAP[client]);
+  const template = readFileSync(templatePath, "utf8");
+  mkdirSync(dirname(targetPath), { recursive: true });
+  if (client === "codex") {
+    writeCodexBootstrap(targetPath, template);
+    return;
+  }
+  writeFileSync(targetPath, ensureTrailingNewline(template), "utf8");
+  process.stderr.write(`Installed ${targetPath}
+`);
+}
+function writeCodexBootstrap(targetPath, template) {
+  const nextContent = ensureTrailingNewline(template);
+  if (!existsSync(targetPath)) {
+    writeFileSync(targetPath, nextContent, "utf8");
+    process.stderr.write(`Installed ${targetPath}
+`);
+    return;
+  }
+  const existing = readFileSync(targetPath, "utf8");
+  if (existing.includes("# Fabric Bootstrap")) {
+    process.stderr.write(`Skipped ${targetPath}: Fabric Bootstrap header already present.
+`);
+    return;
+  }
+  const separator = existing.startsWith("\n") || existing.length === 0 ? "" : "\n";
+  writeFileSync(targetPath, `${nextContent}${separator}${existing}`, "utf8");
+  process.stderr.write(`Prepended ${targetPath}
+`);
+}
+function ensureTrailingNewline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+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 (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Template not found: ${relativePath}`);
+}
+function templateCandidatesFrom(start, relativePath) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(join(current, ...relativePath.split("/")));
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates;
+}
+export {
+  bootstrapCommand,
+  bootstrap_default as default
+};

package/dist/chunk-24U57BQE.js

@@ -0,0 +1,124 @@
+// src/commands/ledger-append.ts
+import { execSync } from "child_process";
+import { appendFileSync, existsSync, readFileSync, statSync } from "fs";
+import { basename, isAbsolute, join, resolve } from "path";
+import { defineCommand } from "citty";
+var LEDGER_FILE = ".intent-ledger.jsonl";
+var INITIAL_PARENT_SHA = "root";
+var ledgerAppendCommand = defineCommand({
+  meta: {
+    name: "ledger-append",
+    description: "Append a Fabric intent ledger entry."
+  },
+  args: {
+    target: {
+      type: "string",
+      description: "Target project path. Defaults to the current working directory.",
+      default: process.cwd()
+    },
+    staged: {
+      type: "boolean",
+      description: "Derive the entry from staged changes for pre-commit.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const target = normalizeTarget(args.target);
+    assertExistingDirectory(target);
+    if (!args.staged) {
+      writeStderr("requires --staged in pre-commit context");
+      process.exitCode = 1;
+      return;
+    }
+    const stagedFiles = getStagedFiles(target).filter((file) => file !== LEDGER_FILE);
+    if (stagedFiles.length === 0) {
+      return;
+    }
+    const intent = deriveIntent(stagedFiles);
+    const diffStat = readDiffStat(target).trim();
+    const entry = {
+      ts: Date.now(),
+      parent_sha: readParentSha(target),
+      intent,
+      affected_paths: stagedFiles,
+      diff_stat: diffStat
+    };
+    if (hasMatchingTailEntry(target, entry)) {
+      return;
+    }
+    appendFileSync(join(target, LEDGER_FILE), `${JSON.stringify(entry)}
+`, "utf8");
+    execGit(target, `git add ${LEDGER_FILE}`);
+  }
+});
+var ledger_append_default = ledgerAppendCommand;
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) {
+    throw new Error(`Target must be an existing directory: ${target}`);
+  }
+}
+function getStagedFiles(target) {
+  const output = execGit(target, "git diff --cached --name-only --no-renames");
+  return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function readDiffStat(target) {
+  return execGit(target, "git diff --cached --stat");
+}
+function readParentSha(target) {
+  try {
+    return execGit(target, "git rev-parse --short HEAD").trim();
+  } catch {
+    return INITIAL_PARENT_SHA;
+  }
+}
+function deriveIntent(stagedFiles) {
+  const explicitIntent = process.env.FABRIC_INTENT?.trim();
+  if (explicitIntent) {
+    return explicitIntent;
+  }
+  const uniqueNames = Array.from(new Set(stagedFiles.map((file) => basename(file))));
+  const head = uniqueNames.slice(0, 2).join(", ");
+  const suffix = uniqueNames.length > 2 ? ` +${uniqueNames.length - 2} more` : "";
+  return `auto: ${head}${suffix}`;
+}
+function hasMatchingTailEntry(target, entry) {
+  const ledgerPath = join(target, LEDGER_FILE);
+  if (!existsSync(ledgerPath)) {
+    return false;
+  }
+  const tail = readFileSync(ledgerPath, "utf8").trim().split(/\r?\n/).filter(Boolean).slice(-1)[0];
+  if (!tail) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(tail);
+    return parsed.parent_sha === entry.parent_sha && parsed.intent === entry.intent && Array.isArray(parsed.affected_paths) && parsed.affected_paths.length === entry.affected_paths.length && parsed.affected_paths.every((value, index) => value === entry.affected_paths[index]) && normalizeDiffStat(parsed.diff_stat) === normalizeDiffStat(entry.diff_stat);
+  } catch {
+    return false;
+  }
+}
+function normalizeDiffStat(diffStat) {
+  if (typeof diffStat !== "string") {
+    return "";
+  }
+  return diffStat.split(/\r?\n/).map((line) => line.trim()).map((line) => line.replace(/\s+\|\s+/g, " | ")).map((line) => line.replace(/\s+/g, " ")).filter((line) => line.length > 0).filter((line) => !line.includes(LEDGER_FILE)).filter((line) => !/\d+ files? changed(?:, \d+ insertions?\(\+\))?(?:, \d+ deletions?\(-\))?$/.test(line.trim())).join("\n");
+}
+function execGit(target, command) {
+  return execSync(command, {
+    cwd: target,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+export {
+  ledgerAppendCommand,
+  ledger_append_default
+};

package/dist/chunk-JLIIQ75E.js

@@ -0,0 +1,65 @@
+// src/dev-mode.ts
+import { existsSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+function readFabricConfig(workspaceRoot = process.cwd()) {
+  const configPath = join(workspaceRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected object in ${configPath}`);
+  }
+  return parsed;
+}
+function resolveDevMode(cliTarget, workspaceRoot = process.cwd()) {
+  const envTarget = normalizeTarget(process.env.EXTERNAL_FIXTURE_PATH, workspaceRoot);
+  const fabricConfig = readFabricConfig(workspaceRoot);
+  const configTarget = normalizeTarget(fabricConfig.externalFixturePath, workspaceRoot);
+  const directTarget = normalizeTarget(cliTarget, workspaceRoot);
+  const chain = [
+    formatResolutionStep("cliTarget", directTarget),
+    formatResolutionStep("EXTERNAL_FIXTURE_PATH", envTarget),
+    formatResolutionStep("fabric.config.json.externalFixturePath", configTarget),
+    formatResolutionStep("process.cwd()", workspaceRoot)
+  ];
+  if (directTarget !== void 0) {
+    return { target: directTarget, source: "cli", chain };
+  }
+  if (envTarget !== void 0) {
+    return { target: envTarget, source: "env", chain };
+  }
+  if (configTarget !== void 0) {
+    return { target: configTarget, source: "config", chain };
+  }
+  return { target: workspaceRoot, source: "cwd", chain };
+}
+function resolveDevModeTarget(cliTarget) {
+  return resolveDevMode(cliTarget).target;
+}
+function createDebugLogger(debug) {
+  const enabled = debug === true || process.env.FABRIC_DEBUG === "1";
+  return (message) => {
+    if (!enabled) {
+      return;
+    }
+    process.stderr.write(`[fabric:debug] ${message}
+`);
+  };
+}
+function normalizeTarget(value, workspaceRoot = process.cwd()) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return void 0;
+  }
+  return isAbsolute(value) ? value : resolve(workspaceRoot, value);
+}
+function formatResolutionStep(source, value) {
+  return `${source}: ${value ?? "<unset>"}`;
+}
+
+export {
+  readFabricConfig,
+  resolveDevMode,
+  resolveDevModeTarget,
+  createDebugLogger
+};

package/dist/chunk-KQ77ZBWO.js

@@ -0,0 +1,94 @@
+// src/commands/human-lint.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { isAbsolute, join, resolve } from "path";
+import { defineCommand } from "citty";
+var humanLintCommand = defineCommand({
+  meta: {
+    name: "human-lint",
+    description: "Validate locked human sections."
+  },
+  args: {
+    target: {
+      type: "string",
+      description: "Target project path. Defaults to the current working directory.",
+      default: process.cwd()
+    }
+  },
+  async run({ args }) {
+    const target = normalizeTarget(args.target);
+    const humanLockPath = join(target, ".fabric", "human-lock.json");
+    if (!existsSync(humanLockPath)) {
+      return;
+    }
+    const parsed = JSON.parse(await readFile(humanLockPath, "utf8"));
+    const locked = Array.isArray(parsed.locked) ? parsed.locked : [];
+    if (locked.length === 0) {
+      return;
+    }
+    const snapshots = await Promise.all(
+      Array.from(new Set(locked.map((entry) => entry.file))).map(async (file) => {
+        try {
+          return {
+            file,
+            content: await readFile(join(target, file), "utf8")
+          };
+        } catch {
+          return {
+            file,
+            content: null
+          };
+        }
+      })
+    );
+    const snapshotByFile = new Map(snapshots.map((snapshot) => [snapshot.file, snapshot]));
+    const violations = [];
+    for (const entry of locked) {
+      const snapshot = snapshotByFile.get(entry.file);
+      const actual = snapshot?.content === null || snapshot === void 0 ? "missing" : hashLockedContent(snapshot.content, entry);
+      if (actual !== entry.hash) {
+        violations.push({
+          location: `${entry.file}:${entry.start_line}-${entry.end_line}`,
+          expected: shortenHash(entry.hash),
+          actual: shortenHash(actual)
+        });
+      }
+    }
+    if (violations.length === 0) {
+      return;
+    }
+    writeStderr("Human-locked content drift detected. Revert the edit or update approved hashes before committing.");
+    writeStderr("Location                         Expected            Got");
+    for (const violation of violations) {
+      writeStderr(
+        `${violation.location.padEnd(32)} ${violation.expected.padEnd(18)} ${violation.actual}`
+      );
+    }
+    process.exitCode = 1;
+  }
+});
+var human_lint_default = humanLintCommand;
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function hashLockedContent(content, entry) {
+  const lines = content.split(/\r?\n/);
+  const slice = lines.slice(Math.max(entry.start_line - 1, 0), Math.max(entry.end_line, 0)).join("\n");
+  return `sha256:${createHash("sha256").update(slice).digest("hex")}`;
+}
+function shortenHash(value) {
+  if (value === "missing") {
+    return value;
+  }
+  return value.slice(0, 15);
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+export {
+  humanLintCommand,
+  human_lint_default
+};