@fenglimg/fabric-cli 0.1.0

package/dist/chunk-RRDTXAUS.js

@@ -0,0 +1,235 @@
+import {
+  createDebugLogger,
+  readFabricConfig,
+  resolveDevMode
+} from "./chunk-JLIIQ75E.js";
+import {
+  resolveIgnores
+} from "./chunk-ZTNSMODH.js";
+
+// src/commands/scan.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { defineCommand } from "citty";
+
+// src/scanner/detector.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function detectFramework(root) {
+  const evidence = [];
+  if (existsSync(join(root, "project.config.json"))) {
+    return {
+      kind: "cocos-creator",
+      evidence: ["project.config.json"]
+    };
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = readPackageJson(packageJsonPath);
+    const deps = collectDependencyNames(packageJson);
+    for (const [dependencyName, kind] of [
+      ["next", "next"],
+      ["vite", "vite"],
+      ["react", "react"],
+      ["vue", "vue"]
+    ]) {
+      if (deps.has(dependencyName)) {
+        evidence.push(`package.json dependency: ${dependencyName}`);
+        return { kind, evidence };
+      }
+    }
+    evidence.push("package.json");
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return {
+      kind: "rust",
+      evidence: ["Cargo.toml"]
+    };
+  }
+  if (existsSync(join(root, "pyproject.toml"))) {
+    return {
+      kind: "python",
+      evidence: ["pyproject.toml"]
+    };
+  }
+  return {
+    kind: "unknown",
+    evidence
+  };
+}
+function readPackageJson(packageJsonPath) {
+  try {
+    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function collectDependencyNames(packageJson) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(packageJson.dependencies ?? {}),
+    ...Object.keys(packageJson.devDependencies ?? {}),
+    ...Object.keys(packageJson.peerDependencies ?? {}),
+    ...Object.keys(packageJson.optionalDependencies ?? {})
+  ]);
+}
+
+// src/commands/scan.ts
+function createScanReport(targetInput = process.cwd(), fabricConfig) {
+  const target = normalizeTarget(targetInput);
+  const framework = detectFramework(target);
+  const readmeQuality = getReadmeQuality(target);
+  const hasContributing = existsSync2(join2(target, "CONTRIBUTING.md"));
+  const hasExistingFabric = existsSync2(join2(target, "AGENTS.md")) || existsSync2(join2(target, ".fabric"));
+  const walkResult = walkFiles(target, resolveIgnores(fabricConfig));
+  return {
+    target,
+    framework,
+    readmeQuality,
+    hasContributing,
+    fileCount: walkResult.fileCount,
+    ignoredCount: walkResult.ignoredCount,
+    hasExistingFabric,
+    recommendations: buildRecommendations({
+      framework,
+      readmeQuality,
+      hasContributing,
+      hasExistingFabric
+    })
+  };
+}
+var scanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: "Scan a project for Fabric bootstrap candidates."
+  },
+  args: {
+    target: {
+      type: "string",
+      description: "Absolute target path to scan. Defaults to CLI target, EXTERNAL_FIXTURE_PATH, fabric.config.json, or cwd."
+    },
+    debug: {
+      type: "boolean",
+      description: "Print detector evidence in pretty output.",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Print the diagnostic report as JSON.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const logger = createDebugLogger(args.debug);
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    const fabricConfig = readFabricConfig(workspaceRoot);
+    logger(`scan target source: ${resolution.source}`);
+    for (const step of resolution.chain) {
+      logger(step);
+    }
+    const report = createScanReport(resolution.target, fabricConfig);
+    if (args.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    printPrettyReport(report, Boolean(args.debug));
+  }
+});
+var scan_default = scanCommand;
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function getReadmeQuality(target) {
+  const readmePath = join2(target, "README.md");
+  if (!existsSync2(readmePath)) {
+    return "stub";
+  }
+  const wordCount = readFileSync2(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
+  return wordCount >= 200 ? "ok" : "stub";
+}
+function walkFiles(root, ignorePatterns) {
+  if (!existsSync2(root) || !statSync(root).isDirectory()) {
+    throw new Error(`Target must be an existing directory: ${root}`);
+  }
+  let fileCount = 0;
+  let ignoredCount = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join2(current, entry.name);
+      const relativePath = toPosixPath(relative(root, absolutePath));
+      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
+        ignoredCount += 1;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile()) {
+        fileCount += 1;
+      }
+    }
+  }
+  return { fileCount, ignoredCount };
+}
+function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
+  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
+}
+function matchesIgnorePattern(relativePath, isDirectory, pattern) {
+  const normalizedPattern = toPosixPath(pattern);
+  if (normalizedPattern === "**/*.meta") {
+    return relativePath.endsWith(".meta");
+  }
+  if (normalizedPattern.endsWith("/**")) {
+    const directoryPrefix = normalizedPattern.slice(0, -3);
+    return relativePath === directoryPrefix || relativePath.startsWith(`${directoryPrefix}/`) || isDirectory && `${relativePath}/` === directoryPrefix;
+  }
+  return relativePath === normalizedPattern;
+}
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+function buildRecommendations(input) {
+  const recommendations = [];
+  if (!input.hasExistingFabric) {
+    recommendations.push("L0: Run fab init to scaffold AGENTS.md with TODO markers.");
+  }
+  if (input.readmeQuality === "stub") {
+    recommendations.push("L0: Expand README.md before promoting project facts into AGENTS.md references.");
+  }
+  if (!input.hasContributing) {
+    recommendations.push("L0: Add CONTRIBUTING.md or leave an AGENTS.md TODO reference for contribution flow.");
+  }
+  if (input.framework.kind === "unknown") {
+    recommendations.push("L1: Add tech-stack TODOs manually because no framework marker was detected.");
+  } else {
+    recommendations.push(`L1: Review ${input.framework.kind} directories for future scoped AGENTS.md files.`);
+  }
+  return recommendations;
+}
+function printPrettyReport(report, debug) {
+  console.log("Fabric scan report");
+  console.log(`Target: ${report.target}`);
+  console.log(`Framework: ${report.framework.kind}`);
+  if (debug) {
+    console.log(`Evidence: ${report.framework.evidence.length > 0 ? report.framework.evidence.join(", ") : "none"}`);
+  }
+  console.log(`README quality: ${report.readmeQuality}`);
+  console.log(`CONTRIBUTING.md: ${report.hasContributing ? "present" : "missing"}`);
+  console.log(`Files counted: ${report.fileCount}`);
+  console.log(`Ignored entries: ${report.ignoredCount}`);
+  console.log(`Existing Fabric files: ${report.hasExistingFabric ? "yes" : "no"}`);
+  console.log("Recommendations:");
+  for (const recommendation of report.recommendations) {
+    console.log(`- ${recommendation}`);
+  }
+}
+
+export {
+  createScanReport,
+  scanCommand,
+  scan_default
+};

package/dist/chunk-ZTNSMODH.js

@@ -0,0 +1,20 @@
+// src/scanner/ignores.ts
+var DEFAULT_IGNORES = [
+  "**/*.meta",
+  "library/**",
+  "temp/**",
+  "build/**",
+  "settings/**",
+  "profiles/**",
+  "node_modules/**",
+  "dist/**",
+  ".git/**",
+  ".fabric/**"
+];
+function resolveIgnores(fabricConfig) {
+  return [...DEFAULT_IGNORES, ...fabricConfig?.scanIgnores ?? []];
+}
+
+export {
+  resolveIgnores
+};

package/dist/config-FC7AKEU7.js

@@ -0,0 +1,119 @@
+import {
+  resolveClients
+} from "./chunk-LHPBYOF5.js";
+
+// src/commands/config.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+var CLIENT_ALIASES = {
+  claudecodecli: "ClaudeCodeCLI",
+  "claude-code-cli": "ClaudeCodeCLI",
+  claudecli: "ClaudeCodeCLI",
+  claudecodedesktop: "ClaudeCodeDesktop",
+  "claude-code-desktop": "ClaudeCodeDesktop",
+  claudedesktop: "ClaudeCodeDesktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  roocode: "RooCode",
+  "roo-code": "RooCode",
+  roo: "RooCode",
+  geminicli: "GeminiCLI",
+  "gemini-cli": "GeminiCLI",
+  gemini: "GeminiCLI",
+  codexcli: "CodexCLI",
+  "codex-cli": "CodexCLI",
+  codex: "CodexCLI"
+};
+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 clientKind = CLIENT_ALIASES[alias];
+    if (clientKind === void 0) {
+      throw new Error(`Unknown client "${rawClient}". Use a comma-separated list such as cursor,codex,gemini.`);
+    }
+    clients.add(clientKind);
+  }
+  return clients;
+}
+async function loadFabricConfig(workspaceRoot) {
+  const configPath = resolve(workspaceRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const parsed = JSON.parse(await readFile(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected object in ${configPath}`);
+  }
+  return parsed;
+}
+function resolveServerPath() {
+  if (process.env.FAB_SERVER_PATH) return resolve(process.env.FAB_SERVER_PATH);
+  return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+var configCmd = defineCommand({
+  meta: {
+    name: "config",
+    description: "Manage Fabric MCP client configuration."
+  },
+  subCommands: {
+    install: defineCommand({
+      meta: {
+        name: "install",
+        description: "Install Fabric MCP server entries into detected client configs."
+      },
+      args: {
+        clients: {
+          type: "string",
+          description: "Optional comma-separated client filter, e.g. cursor,codex,gemini."
+        },
+        "dry-run": {
+          type: "boolean",
+          description: "Print detected writes without changing files.",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const workspaceRoot = process.cwd();
+        const fabricConfig = await loadFabricConfig(workspaceRoot);
+        const selectedClients = parseClientFilter(args.clients);
+        const serverPath = resolveServerPath();
+        const writers = resolveClients(workspaceRoot, fabricConfig).filter(
+          (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
+        );
+        if (writers.length === 0) {
+          writeStderr("No Fabric MCP client configs detected. Create a client directory or set fabric.config.json clientPaths.");
+          return;
+        }
+        for (const writer of writers) {
+          const configPath = await writer.detect(workspaceRoot);
+          if (configPath === null) {
+            writeStderr(`Skipping ${writer.clientKind}: no config path detected.`);
+            continue;
+          }
+          if (args["dry-run"]) {
+            writeStderr(`[dry-run] ${writer.clientKind}: would write ${configPath}`);
+            continue;
+          }
+          await writer.write(serverPath, workspaceRoot);
+          writeStderr(`${writer.clientKind}: wrote ${configPath}`);
+        }
+      }
+    })
+  }
+});
+var config_default = configCmd;
+export {
+  configCmd,
+  config_default as default
+};

package/dist/hooks-2FGWPKQ3.js

@@ -0,0 +1,97 @@
+// src/commands/hooks.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+var hooksCommand = defineCommand({
+  meta: {
+    name: "hooks",
+    description: "Manage Fabric git hook templates."
+  },
+  subCommands: {
+    install: defineCommand({
+      meta: {
+        name: "install",
+        description: "Install the Fabric Husky pre-commit hook template."
+      },
+      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);
+        assertExistingDirectory(target);
+        const huskyDir = join(target, ".husky");
+        const hookPath = join(huskyDir, "pre-commit");
+        const packageJsonPath = join(target, "package.json");
+        if (!existsSync(packageJsonPath)) {
+          throw new Error(`package.json is required to install hooks: ${packageJsonPath}`);
+        }
+        mkdirSync(huskyDir, { recursive: true });
+        writeFileSync(hookPath, readFileSync(findTemplatePath("templates/husky/pre-commit"), "utf8"), "utf8");
+        chmodSync(hookPath, 493);
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const scripts = packageJson.scripts && typeof packageJson.scripts === "object" && !Array.isArray(packageJson.scripts) ? packageJson.scripts : {};
+        const hadPrepare = typeof scripts.prepare === "string" && scripts.prepare.trim().length > 0;
+        if (!hadPrepare) {
+          scripts.prepare = "husky install";
+          packageJson.scripts = scripts;
+          writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+        }
+        writeStderr(`Installed ${hookPath}`);
+        if (hadPrepare) {
+          writeStderr(`Left existing prepare script unchanged in ${packageJsonPath}`);
+        } else {
+          writeStderr(`Added prepare script to ${packageJsonPath}`);
+        }
+      }
+    })
+  }
+});
+var hooks_default = hooksCommand;
+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 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;
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+export {
+  hooks_default as default,
+  hooksCommand
+};

package/dist/human-lint-P7SLDBZK.js

@@ -0,0 +1,8 @@
+import {
+  humanLintCommand,
+  human_lint_default
+} from "./chunk-KQ77ZBWO.js";
+export {
+  human_lint_default as default,
+  humanLintCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import * as citty from 'citty';
+
+declare const main: citty.CommandDef<citty.ArgsDef>;
+declare function run(): Promise<void>;
+
+export { main, run };

package/dist/index.js

@@ -0,0 +1,40 @@
+// src/index.ts
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand, runMain } from "citty";
+
+// src/commands/index.ts
+var allCommands = {
+  bootstrap: () => import("./bootstrap-5JAUC3JW.js").then((module) => module.default),
+  init: () => import("./init-OM7PLR3J.js").then((module) => module.default),
+  scan: () => import("./scan-SE25KUZV.js").then((module) => module.default),
+  "sync-meta": () => import("./sync-meta-WM3A7FJP.js").then((module) => module.default),
+  "human-lint": () => import("./human-lint-P7SLDBZK.js").then((module) => module.default),
+  "ledger-append": () => import("./ledger-append-WA6ZJSMS.js").then((module) => module.default),
+  hooks: () => import("./hooks-2FGWPKQ3.js").then((module) => module.default),
+  config: () => import("./config-FC7AKEU7.js").then((module) => module.configCmd),
+  "pre-commit": () => import("./pre-commit-XKYQGUMV.js").then((module) => module.default)
+};
+
+// src/index.ts
+var main = defineCommand({
+  meta: {
+    name: "fab",
+    version: "0.0.0",
+    description: "Fabric CLI"
+  },
+  subCommands: allCommands
+});
+async function run() {
+  await runMain(main);
+}
+var entrypoint = process.argv[1];
+var currentFilePath = fileURLToPath(import.meta.url);
+var isMainModule = entrypoint !== void 0 && resolve(entrypoint) === currentFilePath;
+if (isMainModule) {
+  void run();
+}
+export {
+  main,
+  run
+};

package/dist/init-OM7PLR3J.js

@@ -0,0 +1,148 @@
+import {
+  createScanReport
+} from "./chunk-RRDTXAUS.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-JLIIQ75E.js";
+import "./chunk-ZTNSMODH.js";
+
+// src/commands/init.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize Fabric in a target project."
+  },
+  args: {
+    target: {
+      type: "string",
+      description: "Target project path. Defaults to CLI target, EXTERNAL_FIXTURE_PATH, fabric.config.json, or cwd."
+    },
+    debug: {
+      type: "boolean",
+      description: "Print target resolution details to stderr.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createDebugLogger(args.debug);
+    const resolution = resolveDevMode(args.target, process.cwd());
+    const target = normalizeTarget(resolution.target);
+    logger(`init target source: ${resolution.source}`);
+    for (const step of resolution.chain) {
+      logger(step);
+    }
+    const created = initFabric(target);
+    console.log(`Created ${created.agentsPath}`);
+    console.log(`Created ${created.metaPath}`);
+    console.log(`Created ${created.humanLockPath}`);
+    console.log("Next: run fab hooks install to add the Day 4 pre-commit pipeline.");
+  }
+});
+var init_default = initCommand;
+function initFabric(target) {
+  assertExistingDirectory(target);
+  const agentsPath = join(target, "AGENTS.md");
+  const fabricDir = join(target, ".fabric");
+  if (existsSync(agentsPath)) {
+    throw new Error(`ABORT: ${agentsPath} already exists. fab init is non-destructive.`);
+  }
+  if (existsSync(fabricDir)) {
+    throw new Error(`ABORT: ${fabricDir} already exists. fab init is non-destructive.`);
+  }
+  const scanReport = createScanReport(target);
+  const template = readFileSync(findTemplatePath("templates/agents-md/AGENTS.md.template"), "utf8");
+  const humanLockTemplate = readFileSync(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
+  const packageName = readPackageName(target) ?? "// TODO: project name";
+  const agentsContent = template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind);
+  const agentsHash = sha256(agentsContent);
+  const meta = createInitialMeta(agentsHash);
+  const metaPath = join(fabricDir, "agents.meta.json");
+  const humanLockPath = join(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}
+`);
+  return { agentsPath, metaPath, humanLockPath };
+}
+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 createInitialMeta(agentsHash) {
+  return {
+    revision: sha256(agentsHash),
+    nodes: {
+      L0: {
+        file: "AGENTS.md",
+        scope_glob: "**",
+        deps: [],
+        priority: "high",
+        hash: agentsHash
+      }
+    }
+  };
+}
+function readPackageName(target) {
+  const packageJsonPath = join(target, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return void 0;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(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 (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;
+}
+function writeNewFile(path, content) {
+  if (existsSync(path)) {
+    throw new Error(`ABORT: ${path} already exists. fab init is non-destructive.`);
+  }
+  writeFileSync(path, content, "utf8");
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+export {
+  init_default as default,
+  initCommand,
+  initFabric
+};

package/dist/ledger-append-WA6ZJSMS.js

@@ -0,0 +1,8 @@
+import {
+  ledgerAppendCommand,
+  ledger_append_default
+} from "./chunk-24U57BQE.js";
+export {
+  ledger_append_default as default,
+  ledgerAppendCommand
+};