@fenglimg/fabric-cli 2.2.0-rc.3 → 2.2.0-rc.8

package/dist/chunk-QPAW6IYT.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+import {
+  loadProjectConfig,
+  saveProjectConfig
+} from "./chunk-QFIVFZRH.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-FNHDQTPC.js";
+
+// src/store/store-ops.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  addMountedStore,
+  addStoreProject,
+  bindRequiredStore,
+  deriveMountLabel,
+  detachMountedStore,
+  explainStore,
+  initStore,
+  STORE_GITIGNORE,
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  STORE_LAYOUT,
+  STORE_PENDING_DIR,
+  STORES_ROOT_DIR,
+  storeHasProject,
+  storeIdentitySchema,
+  storeProjectsFileSchema,
+  storeMountSubPath,
+  storeRelativePath,
+  storeRelativePathForMount,
+  storeMountNameSchema,
+  writeRouteSchema
+} from "@fenglimg/fabric-shared";
+var NO_GLOBAL_CONFIG = "no global Fabric config found \u2014 run `fabric install --global <url>` first";
+function requireConfig(globalRoot) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  return config;
+}
+function storeList(globalRoot = resolveGlobalRoot()) {
+  return requireConfig(globalRoot).stores;
+}
+function mountedStoreDir(store, globalRoot) {
+  return join(globalRoot, storeRelativePathForMount(store));
+}
+function resolveStoreByAliasOrUuid(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return null;
+  }
+  return config.stores.find(
+    (s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid || s.mount_name === aliasOrUuid
+  ) ?? null;
+}
+var STORE_BY_ALIAS_DIR = "by-alias";
+function syncStoreAliasLinks(globalRoot = resolveGlobalRoot()) {
+  const result = { created: [], removed: [], errors: [] };
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return result;
+  }
+  const byAliasDir = join(globalRoot, STORES_ROOT_DIR, STORE_BY_ALIAS_DIR);
+  const desired = new Map(config.stores.map((s) => [s.alias, storeMountSubPath(s)]));
+  try {
+    mkdirSync(byAliasDir, { recursive: true });
+  } catch {
+    return result;
+  }
+  let existing = [];
+  try {
+    existing = readdirSync(byAliasDir);
+  } catch {
+    existing = [];
+  }
+  for (const name of existing) {
+    if (desired.has(name)) {
+      continue;
+    }
+    try {
+      rmSync(join(byAliasDir, name), { force: true, recursive: false });
+      result.removed.push(name);
+    } catch {
+      result.errors.push(name);
+    }
+  }
+  for (const [alias, mountName] of desired) {
+    const link = join(byAliasDir, alias);
+    const target = join("..", mountName);
+    try {
+      let current = null;
+      try {
+        if (lstatSync(link).isSymbolicLink()) {
+          current = readlinkSync(link);
+        }
+      } catch {
+        current = null;
+      }
+      if (current === target) {
+        continue;
+      }
+      rmSync(link, { force: true });
+      symlinkSync(target, link);
+      result.created.push(alias);
+    } catch {
+      result.errors.push(alias);
+    }
+  }
+  return result;
+}
+function detectAliasLinkDrift(globalRoot = resolveGlobalRoot()) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return [];
+  }
+  const byAliasDir = join(globalRoot, STORES_ROOT_DIR, STORE_BY_ALIAS_DIR);
+  if (!existsSync(byAliasDir)) {
+    return [];
+  }
+  const drifted = [];
+  for (const store of config.stores) {
+    const link = join(byAliasDir, store.alias);
+    const target = join("..", storeMountSubPath(store));
+    try {
+      if (!lstatSync(link).isSymbolicLink() || readlinkSync(link) !== target) {
+        drifted.push(store.alias);
+      }
+    } catch {
+      drifted.push(store.alias);
+    }
+  }
+  return drifted;
+}
+function storeAdd(store, globalRoot = resolveGlobalRoot()) {
+  const next = addMountedStore(requireConfig(globalRoot), store);
+  saveGlobalConfig(next, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return next;
+}
+async function storeCreate(alias, now, options = {}) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const config = requireConfig(globalRoot);
+  const uuid = options.uuid ?? randomUUID();
+  const mount_name = options.mountName !== void 0 ? storeMountNameSchema.parse(options.mountName) : deriveMountLabel({ remote: options.remote, alias, store_uuid: uuid });
+  const mountedBase = { store_uuid: uuid, alias, mount_name };
+  const storeDir = mountedStoreDir(mountedBase, globalRoot);
+  const identity = { store_uuid: uuid, created_at: now, canonical_alias: alias };
+  if (options.git === false) {
+    initStoreSync(storeDir, identity);
+  } else {
+    await initStore(storeDir, identity, { git: options.git });
+  }
+  if (options.remote !== void 0 && options.git !== false) {
+    gitRemoteAdd(storeDir, options.remote);
+  }
+  const mounted = options.remote === void 0 ? mountedBase : { ...mountedBase, remote: options.remote };
+  const next = addMountedStore(config, mounted);
+  saveGlobalConfig(next, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return { config: next, store_uuid: uuid, storeDir };
+}
+function initStoreSync(absDir, identity) {
+  const parsed = storeIdentitySchema.parse(identity);
+  const identityFile = join(absDir, STORE_LAYOUT.identityFile);
+  if (existsSync(identityFile)) {
+    throw new Error(`store already initialized at ${absDir} (store.json exists)`);
+  }
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    const typeDir = join(absDir, STORE_LAYOUT.knowledgeDir, type);
+    mkdirSync(typeDir, { recursive: true });
+    writeFileSync(join(typeDir, ".gitkeep"), "", "utf8");
+  }
+  mkdirSync(join(absDir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR), { recursive: true });
+  mkdirSync(join(absDir, STORE_LAYOUT.bindingsDir), { recursive: true });
+  mkdirSync(join(absDir, STORE_LAYOUT.stateDir), { recursive: true });
+  writeFileSync(identityFile, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  writeFileSync(join(absDir, ".gitignore"), STORE_GITIGNORE, "utf8");
+  return parsed;
+}
+function gitRemoteAdd(storeDir, remote) {
+  try {
+    execFileSync("git", ["remote", "add", "origin", remote], {
+      cwd: storeDir,
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+  } catch {
+    try {
+      execFileSync("git", ["remote", "set-url", "origin", remote], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    } catch {
+    }
+  }
+}
+function storeGitRemote(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const storeDir = resolveStoreDir(aliasOrUuid, globalRoot) ?? join(globalRoot, storeRelativePath(aliasOrUuid));
+  if (!existsSync(storeDir)) {
+    return void 0;
+  }
+  try {
+    const out = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8"
+    });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function assertStoreMountable(uuid, globalRoot = resolveGlobalRoot(), mountName) {
+  const registered = resolveStoreByAliasOrUuid(uuid, globalRoot);
+  const candidates = mountName === void 0 && registered === null ? [join(globalRoot, storeRelativePath(uuid))] : [
+    join(
+      globalRoot,
+      storeRelativePathForMount({
+        store_uuid: uuid,
+        mount_name: mountName ?? registered?.mount_name,
+        personal: registered?.personal
+      })
+    ),
+    join(globalRoot, storeRelativePath(uuid))
+  ];
+  const storeDir = candidates.find((dir) => existsSync(join(dir, "store.json"))) ?? candidates[0];
+  if (!existsSync(join(storeDir, "store.json"))) {
+    throw new Error(
+      `cannot mount store ${uuid}: no store tree at ${storeDir} \u2014 clone it first (\`fabric install --global --url <remote>\`) or create it locally, then re-run \`fabric store add\`. Refusing to register a phantom store.`
+    );
+  }
+}
+function storeRemove(alias, globalRoot = resolveGlobalRoot()) {
+  const result = detachMountedStore(requireConfig(globalRoot), alias);
+  saveGlobalConfig(result.config, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return result;
+}
+function storeExplain(alias, globalRoot = resolveGlobalRoot()) {
+  return explainStore(requireConfig(globalRoot), alias);
+}
+var NO_PROJECT_CONFIG = "no project Fabric config \u2014 run `fabric install` in this repo first";
+function requireProjectConfig(projectRoot) {
+  const config = loadProjectConfig(projectRoot);
+  if (config === null) {
+    throw new Error(NO_PROJECT_CONFIG);
+  }
+  return config;
+}
+function resolveStoreDir(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const store = resolveStoreByAliasOrUuid(aliasOrUuid, globalRoot);
+  if (store === null) {
+    return null;
+  }
+  return mountedStoreDir(store, globalRoot);
+}
+function storeProjectList(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const storeDir = resolveStoreDir(aliasOrUuid, globalRoot);
+  if (storeDir === null) {
+    throw new Error(`no mounted store '${aliasOrUuid}' \u2014 run \`fabric store list\` to see mounts`);
+  }
+  return readStoreProjectsSync(storeDir);
+}
+function readStoreProjectsSync(storeDir) {
+  try {
+    const parsed = storeProjectsFileSchema.safeParse(
+      JSON.parse(readFileSync(join(storeDir, STORE_LAYOUT.projectsFile), "utf8"))
+    );
+    return parsed.success ? parsed.data.projects : [];
+  } catch {
+    return [];
+  }
+}
+async function storeProjectCreate(aliasOrUuid, id, now, options = {}) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const storeDir = resolveStoreDir(aliasOrUuid, globalRoot);
+  if (storeDir === null) {
+    throw new Error(`no mounted store '${aliasOrUuid}' \u2014 run \`fabric store list\` to see mounts`);
+  }
+  const project = options.name === void 0 ? { id, created_at: now } : { id, name: options.name, created_at: now };
+  await addStoreProject(storeDir, project);
+  return project;
+}
+async function storeBind(projectRoot, entry, options = {}) {
+  const config = requireProjectConfig(projectRoot);
+  let activeProject = config.active_project;
+  if (options.project !== void 0) {
+    const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+    const storeDir = resolveStoreDir(entry.id, globalRoot);
+    if (storeDir === null) {
+      throw new Error(
+        `cannot bind project '${options.project}': store '${entry.id}' is not mounted \u2014 mount it first (\`fabric store add\` / \`fabric install --global --url <remote>\`)`
+      );
+    }
+    if (!await storeHasProject(storeDir, options.project)) {
+      throw new Error(
+        `cannot bind to project '${options.project}': not registered in store '${entry.id}' \u2014 create it first with \`fabric store project create ${entry.id} ${options.project}\``
+      );
+    }
+    activeProject = options.project;
+  }
+  const next = {
+    ...config,
+    required_stores: bindRequiredStore(config.required_stores ?? [], entry),
+    ...activeProject === void 0 ? {} : { active_project: activeProject }
+  };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function storeSwitchWrite(projectRoot, alias, options = {}) {
+  const config = requireProjectConfig(projectRoot);
+  const store = resolveStoreByAliasOrUuid(alias, options.globalRoot ?? resolveGlobalRoot());
+  if (store === null || store.personal === true || store.writable === false) {
+    throw new Error(`cannot set default write store '${alias}': mount a writable shared store first`);
+  }
+  const next = {
+    ...config,
+    active_write_store: alias,
+    default_write_store: alias
+  };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function storeSetWriteRoute(projectRoot, scope, alias, options = {}) {
+  const config = requireProjectConfig(projectRoot);
+  const route = writeRouteSchema.parse({ scope, store: alias });
+  const store = resolveStoreByAliasOrUuid(alias, options.globalRoot ?? resolveGlobalRoot());
+  if (store === null || store.personal === true || store.writable === false) {
+    throw new Error(`cannot route scope '${scope}' to '${alias}': mount a writable shared store first`);
+  }
+  const routes = [
+    ...(config.write_routes ?? []).filter((existing) => existing.scope !== route.scope),
+    route
+  ];
+  const next = { ...config, write_routes: routes };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function missingRequiredStores(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const project = loadProjectConfig(projectRoot);
+  if (project === null || project.required_stores === void 0) {
+    return [];
+  }
+  const global = loadGlobalConfig(globalRoot);
+  const mounted = new Set(
+    (global?.stores ?? []).flatMap((s) => [s.alias, s.store_uuid])
+  );
+  return project.required_stores.filter((r) => !mounted.has(r.id));
+}
+function unboundAvailableStores(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const global = loadGlobalConfig(globalRoot);
+  if (global === null) {
+    return [];
+  }
+  const project = loadProjectConfig(projectRoot);
+  const declared = new Set((project?.required_stores ?? []).map((r) => r.id));
+  return global.stores.filter(
+    (s) => s.personal !== true && !declared.has(s.alias) && !declared.has(s.store_uuid)
+  );
+}
+
+export {
+  storeList,
+  syncStoreAliasLinks,
+  detectAliasLinkDrift,
+  storeAdd,
+  storeCreate,
+  storeGitRemote,
+  assertStoreMountable,
+  storeRemove,
+  storeExplain,
+  resolveStoreDir,
+  storeProjectList,
+  storeProjectCreate,
+  storeBind,
+  storeSwitchWrite,
+  storeSetWriteRoute,
+  missingRequiredStores,
+  unboundAvailableStores
+};

package/dist/{chunk-COI5VDFU.js → chunk-WA3DYGSY.js}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 // src/dev-mode.ts
-import { existsSync, readFileSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
+import { isAbsolute, resolve } from "path";
 function resolveDevMode(cliTarget, workspaceRoot = process.cwd()) {
   const envTarget = normalizeTarget(process.env.EXTERNAL_FIXTURE_PATH, workspaceRoot);
   const directTarget = normalizeTarget(cliTarget, workspaceRoot);

package/dist/{plan-context-hint-CHVZGOZ5.js → chunk-YM4XATJF.js}

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-COI5VDFU.js";
+} from "./chunk-WA3DYGSY.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
-import { planContext } from "@fenglimg/fabric-server";
+import {
+  buildAlwaysActiveBodies,
+  buildKnowledgeCensus,
+  planContext
+} from "@fenglimg/fabric-server";
 var ALL_PATHS_SENTINEL = "**";
 var planContextHintCommand = defineCommand({
   meta: {
@@ -74,6 +78,9 @@ async function runPlanContextHint(opts) {
       maturity: item.description.maturity ?? "",
       summary: item.description.summary,
       relevance_scope: item.description.relevance_scope ?? "broad",
+      // W2-2 (KT-DEC-0027): forward the must_read_if trigger hook for the
+      // SessionStart REFERENCE rendering. Omitted when absent/empty.
+      ...typeof item.description.must_read_if === "string" && item.description.must_read_if.length > 0 ? { must_read_if: item.description.must_read_if } : {},
       // Only set when this entry was pulled in via a graph edge — its presence
       // is the honest signal, never synthesized for ordinarily-ranked entries.
       ...typeof relatedTo === "string" ? { related_to: relatedTo } : {}
@@ -85,6 +92,15 @@ async function runPlanContextHint(opts) {
     if (e.relevance_scope === "narrow") narrow_count += 1;
     else broad_only_count += 1;
   }
+  const alwaysBodies = await buildAlwaysActiveBodies(resolution.target).catch(() => []);
+  const census = await buildKnowledgeCensus(resolution.target).catch(
+    () => ({
+      by_type: {},
+      by_layer: { team: 0, personal: 0, project: 0 },
+      dropped_other_project: 0,
+      total: 0
+    })
+  );
   const output = {
     version: 2,
     revision_hash: result.revision_hash,
@@ -94,7 +110,15 @@ async function runPlanContextHint(opts) {
     // semantics unchanged from rc.18 (total candidate count).
     broad_count: candidates.length,
     narrow_count,
-    broad_only_count
+    broad_only_count,
+    always_bodies: alwaysBodies.map((b) => ({
+      id: b.stable_id,
+      type: b.type,
+      layer: b.layer,
+      summary: b.summary,
+      body: b.body
+    })),
+    census
   };
   if (result.auto_healed === true) {
     output.auto_healed = true;
@@ -110,8 +134,9 @@ function parsePathsArg(raw) {
   }
   return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
+
 export {
-  plan_context_hint_default as default,
   planContextHintCommand,
+  plan_context_hint_default,
   runPlanContextHint
 };

package/dist/{config-VJMXCLXW.js → config-A3LTECAY.js}

@@ -3,9 +3,10 @@ import {
   configCmd,
   config_default,
   installMcpClients
-} from "./chunk-F6ITRM7T.js";
-import "./chunk-XC5RUHLK.js";
-import "./chunk-2CY4BMTH.js";
+} from "./chunk-2KBCTMID.js";
+import "./chunk-3IOLS5EK.js";
+import "./chunk-FNHDQTPC.js";
+import "./chunk-HORSMSZL.js";
 export {
   configCmd,
   config_default as default,

package/dist/context-7NUKXDB6.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import {
+  runPlanContextHint
+} from "./chunk-YM4XATJF.js";
+import "./chunk-WA3DYGSY.js";
+
+// src/commands/context.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+function findTemplatePath(relativePath) {
+  const startDir = dirname(fileURLToPath(import.meta.url));
+  let current = resolve(startDir);
+  for (; ; ) {
+    const candidate = join(current, "templates", relativePath);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      throw new Error(`Template not found: templates/${relativePath} (searched up from ${startDir})`);
+    }
+    current = parent;
+  }
+}
+function loadHookRenderer() {
+  const require2 = createRequire(import.meta.url);
+  return require2(findTemplatePath("hooks/knowledge-hint-broad.cjs"));
+}
+function renderExplain(sinks) {
+  const payload = sinks.resolvedPayload;
+  const lines = ["", "\u2014 explain (provenance; not injected) \u2014"];
+  const bodies = Array.isArray(payload?.always_bodies) ? payload.always_bodies : [];
+  if (bodies.length > 0) {
+    lines.push("always-active (body injected):");
+    for (const b of bodies) {
+      lines.push(`  [${b.type}] ${b.id} (${b.layer}) \xB7 ${b.summary}`);
+    }
+  }
+  const entries = Array.isArray(payload?.entries) ? payload.entries : [];
+  if (entries.length > 0) {
+    lines.push("reference / candidates:");
+    for (const e of entries) {
+      const provenance = typeof e.related_to === "string" ? ` \u2190related-to:${e.related_to}` : "";
+      lines.push(
+        `  [${e.type}] ${e.id} (${e.maturity || "?"}, ${e.relevance_scope})${provenance} \xB7 ${e.summary}`
+      );
+      if (typeof e.must_read_if === "string" && e.must_read_if.length > 0) {
+        lines.push(`    must_read_if: ${e.must_read_if}`);
+      }
+    }
+  }
+  const census = payload?.census;
+  if (census) {
+    const layer = census.by_layer ?? { team: 0, personal: 0, project: 0 };
+    lines.push(
+      `census: total ${census.total} \xB7 [team]${layer.team ?? 0} [project]${layer.project ?? 0} [personal]${layer.personal ?? 0}`
+    );
+  }
+  return lines.join("\n");
+}
+async function runContext(opts) {
+  const cwd = opts.target ? resolve(opts.target) : process.cwd();
+  const payload = opts.payload !== void 0 ? opts.payload : await runPlanContextHint({ all: true, target: opts.target });
+  const renderer = loadHookRenderer();
+  const sinks = renderer.buildSessionStartSinks(cwd, payload, {});
+  let base;
+  if (opts.render === "ai") {
+    base = sinks.ai ?? "";
+  } else if (opts.render === "human") {
+    base = sinks.human ?? "";
+  } else {
+    base = [sinks.human, sinks.ai].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
+  }
+  if (base.length === 0 && !sinks.hasRenderedContent) return "";
+  return opts.explain === true ? base + "\n" + renderExplain(sinks) : base;
+}
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "Show what Fabric injects at SessionStart (the knowledge spine). --explain for per-entry provenance."
+  },
+  args: {
+    render: {
+      type: "string",
+      description: "Which sink to show: 'human' (systemMessage) or 'ai' (additionalContext). Default: both."
+    },
+    explain: {
+      type: "boolean",
+      description: "Append a per-entry provenance section (id \xB7 type \xB7 maturity \xB7 scope \xB7 why-surfaced).",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Override the project root (defaults to cwd / dev-mode resolution)."
+    }
+  },
+  async run({ args }) {
+    try {
+      const render = args.render === "human" || args.render === "ai" ? args.render : void 0;
+      const out = await runContext({ render, explain: args.explain === true, target: args.target });
+      if (out.length > 0) process.stdout.write(`${out}
+`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`context failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
+var context_default = contextCommand;
+export {
+  contextCommand,
+  context_default as default,
+  runContext
+};

package/dist/doctor-REZDNH4A.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  doctorCommand,
+  doctor_default,
+  parseSinceDuration,
+  renderDoctorFilteredHelp,
+  renderTldrHeader
+} from "./chunk-JTHWLUD3.js";
+import "./chunk-FEOPLBGA.js";
+import "./chunk-WA3DYGSY.js";
+import "./chunk-NLNH64A3.js";
+import "./chunk-PTGQAZEW.js";
+import "./chunk-EOT63RDH.js";
+import "./chunk-QPAW6IYT.js";
+import "./chunk-QFIVFZRH.js";
+import "./chunk-FNHDQTPC.js";
+import "./chunk-HORSMSZL.js";
+export {
+  doctor_default as default,
+  doctorCommand,
+  parseSinceDuration,
+  renderDoctorFilteredHelp,
+  renderTldrHeader
+};

package/dist/index.d.ts

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