@fenglimg/fabric-cli 2.1.0-rc.2 → 2.2.0-rc.3

package/dist/chunk-HFQVXY6P.js

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadProjectConfig,
-  saveProjectConfig
-} from "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot,
-  saveGlobalConfig
-} from "./chunk-RYAFBNES.js";
-
-// src/store/store-ops.ts
-import {
-  addMountedStore,
-  bindRequiredStore,
-  detachMountedStore,
-  explainStore
-} 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 storeAdd(store, globalRoot = resolveGlobalRoot()) {
-  const next = addMountedStore(requireConfig(globalRoot), store);
-  saveGlobalConfig(next, globalRoot);
-  return next;
-}
-function storeRemove(alias, globalRoot = resolveGlobalRoot()) {
-  const result = detachMountedStore(requireConfig(globalRoot), alias);
-  saveGlobalConfig(result.config, 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 storeBind(projectRoot, entry) {
-  const config = requireProjectConfig(projectRoot);
-  const next = {
-    ...config,
-    required_stores: bindRequiredStore(config.required_stores ?? [], entry)
-  };
-  saveProjectConfig(next, projectRoot);
-  return next;
-}
-function storeSwitchWrite(projectRoot, alias) {
-  const config = requireProjectConfig(projectRoot);
-  const next = { ...config, active_write_store: alias };
-  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));
-}
-
-export {
-  storeList,
-  storeAdd,
-  storeRemove,
-  storeExplain,
-  storeBind,
-  storeSwitchWrite,
-  missingRequiredStores
-};

package/dist/chunk-L4Q55UC4.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadProjectConfig
-} from "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
-
-// src/store/scope-explain.ts
-import {
-  createStoreResolver
-} from "@fenglimg/fabric-shared";
-function buildResolveInput(projectRoot, globalRoot = resolveGlobalRoot()) {
-  const global = loadGlobalConfig(globalRoot);
-  if (global === null) {
-    return null;
-  }
-  const project = loadProjectConfig(projectRoot);
-  return {
-    uid: global.uid,
-    mountedStores: global.stores.map((s) => ({
-      store_uuid: s.store_uuid,
-      alias: s.alias,
-      ...s.remote === void 0 ? {} : { remote: s.remote },
-      writable: s.writable ?? true,
-      personal: s.personal ?? false
-    })),
-    requiredStores: (project?.required_stores ?? []).map((r) => ({
-      id: r.id,
-      ...r.suggested_remote === void 0 ? {} : { suggested_remote: r.suggested_remote }
-    })),
-    ...project?.active_write_store === void 0 ? {} : { activeWriteAlias: project.active_write_store }
-  };
-}
-function scopeExplain(projectRoot, scope, globalRoot = resolveGlobalRoot()) {
-  const input = buildResolveInput(projectRoot, globalRoot);
-  if (input === null) {
-    return null;
-  }
-  const resolver = createStoreResolver();
-  return {
-    scope,
-    readSet: resolver.resolveReadSet(input),
-    writeTarget: resolver.resolveWriteTarget(input, scope).target
-  };
-}
-
-export {
-  buildResolveInput,
-  scopeExplain
-};

package/dist/chunk-LFIKMVY7.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-
-// src/store/project-config-io.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { fabricConfigSchema } from "@fenglimg/fabric-shared";
-function projectConfigPath(projectRoot) {
-  return join(projectRoot, ".fabric", "fabric-config.json");
-}
-function loadProjectConfig(projectRoot) {
-  const path = projectConfigPath(projectRoot);
-  if (!existsSync(path)) {
-    return null;
-  }
-  return fabricConfigSchema.parse(JSON.parse(readFileSync(path, "utf8")));
-}
-function saveProjectConfig(config, projectRoot) {
-  const validated = fabricConfigSchema.parse(config);
-  mkdirSync(join(projectRoot, ".fabric"), { recursive: true });
-  writeFileSync(projectConfigPath(projectRoot), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
-}
-
-export {
-  loadProjectConfig,
-  saveProjectConfig
-};

package/dist/chunk-RYAFBNES.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-// src/store/global-config-io.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { globalConfigSchema } from "@fenglimg/fabric-shared";
-function resolveGlobalRoot() {
-  return join(process.env.FABRIC_HOME ?? homedir(), ".fabric");
-}
-function globalConfigPath(globalRoot = resolveGlobalRoot()) {
-  return join(globalRoot, "fabric-global.json");
-}
-function loadGlobalConfig(globalRoot = resolveGlobalRoot()) {
-  const path = globalConfigPath(globalRoot);
-  if (!existsSync(path)) {
-    return null;
-  }
-  return globalConfigSchema.parse(JSON.parse(readFileSync(path, "utf8")));
-}
-function saveGlobalConfig(config, globalRoot = resolveGlobalRoot()) {
-  const validated = globalConfigSchema.parse(config);
-  mkdirSync(globalRoot, { recursive: true });
-  writeFileSync(globalConfigPath(globalRoot), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
-}
-
-export {
-  resolveGlobalRoot,
-  globalConfigPath,
-  loadGlobalConfig,
-  saveGlobalConfig
-};

package/dist/chunk-T5RPGCCM.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadProjectConfig
-} from "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
-
-// src/store/info-ops.ts
-function whoami(globalRoot = resolveGlobalRoot()) {
-  const config = loadGlobalConfig(globalRoot);
-  if (config === null) {
-    return null;
-  }
-  return {
-    uid: config.uid,
-    stores: config.stores.map((s) => ({
-      alias: s.alias,
-      store_uuid: s.store_uuid,
-      local_only: s.remote === void 0
-    }))
-  };
-}
-function projectStatus(projectRoot, globalRoot = resolveGlobalRoot()) {
-  const global = loadGlobalConfig(globalRoot);
-  const project = loadProjectConfig(projectRoot);
-  return {
-    uid: global?.uid ?? null,
-    mounted: (global?.stores ?? []).map((s) => s.alias),
-    project_id: project?.project_id ?? null,
-    required: (project?.required_stores ?? []).map((r) => r.id),
-    active_write_store: project?.active_write_store ?? null
-  };
-}
-
-export {
-  whoami,
-  projectStatus
-};

package/dist/store-XTSE5TY6.js

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-import {
-  storeAdd,
-  storeBind,
-  storeExplain,
-  storeList,
-  storeRemove,
-  storeSwitchWrite
-} from "./chunk-HFQVXY6P.js";
-import {
-  regenerateBindingsSnapshot
-} from "./chunk-WU6GAPKH.js";
-import "./chunk-L4Q55UC4.js";
-import "./chunk-LFIKMVY7.js";
-import "./chunk-RYAFBNES.js";
-
-// src/commands/store.ts
-import { defineCommand } from "citty";
-var listCommand = defineCommand({
-  meta: { name: "list", description: "List mounted knowledge stores" },
-  run() {
-    const stores = storeList();
-    if (stores.length === 0) {
-      console.log("(no stores mounted)");
-      return;
-    }
-    for (const store of stores) {
-      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? "(local-only)"}`);
-    }
-  }
-});
-var addCommand = defineCommand({
-  meta: { name: "add", description: "Mount a knowledge store into the global registry" },
-  args: {
-    uuid: { type: "string", required: true, description: "Intrinsic store UUID" },
-    alias: { type: "string", required: true, description: "Local alias for this store" },
-    remote: { type: "string", description: "Git remote locator (omit for local-only)" }
-  },
-  run({ args }) {
-    const store = args.remote === void 0 ? { store_uuid: args.uuid, alias: args.alias } : { store_uuid: args.uuid, alias: args.alias, remote: args.remote };
-    const next = storeAdd(store);
-    console.log(`mounted '${args.alias}' (${next.stores.length} store(s) total)`);
-  }
-});
-var removeCommand = defineCommand({
-  meta: { name: "remove", description: "Detach a store from the registry (does NOT delete it)" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias to detach" }
-  },
-  run({ args }) {
-    const { detached } = storeRemove(args.alias);
-    console.log(
-      detached === null ? `no store aliased '${args.alias}'` : `detached '${args.alias}' \u2014 on-disk store tree left intact (detach \u2260 delete)`
-    );
-  }
-});
-var explainCommand = defineCommand({
-  meta: { name: "explain", description: "Explain how a store alias resolves" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias to explain" }
-  },
-  run({ args }) {
-    const explanation = storeExplain(args.alias);
-    console.log(
-      explanation === null ? `no store aliased '${args.alias}'` : JSON.stringify(explanation, null, 2)
-    );
-  }
-});
-var bindCommand = defineCommand({
-  meta: { name: "bind", description: "Declare a required store on this project's config" },
-  args: {
-    id: { type: "positional", required: true, description: "Store alias/UUID to require" },
-    remote: { type: "string", description: "Suggested remote for clone onboarding" }
-  },
-  run({ args }) {
-    const entry = args.remote === void 0 ? { id: args.id } : { id: args.id, suggested_remote: args.remote };
-    const next = storeBind(process.cwd(), entry);
-    console.log(`bound required store '${args.id}' (${next.required_stores?.length ?? 0} required)`);
-    regenerateBindingsSnapshot(process.cwd(), { now: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-});
-var switchWriteCommand = defineCommand({
-  meta: { name: "switch-write", description: "Set the active write store for non-personal scopes" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias of the store to write to" }
-  },
-  run({ args }) {
-    storeSwitchWrite(process.cwd(), args.alias);
-    console.log(`active write store set to '${args.alias}' for this project`);
-  }
-});
-var store_default = defineCommand({
-  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
-  subCommands: {
-    list: listCommand,
-    add: addCommand,
-    remove: removeCommand,
-    explain: explainCommand,
-    bind: bindCommand,
-    "switch-write": switchWriteCommand
-  }
-});
-export {
-  store_default as default
-};

package/dist/sync-BJCWDPNC.js

@@ -1,245 +0,0 @@
-#!/usr/bin/env node
-import {
-  regenerateBindingsSnapshot
-} from "./chunk-WU6GAPKH.js";
-import "./chunk-L4Q55UC4.js";
-import "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
-
-// src/commands/sync.ts
-import { defineCommand } from "citty";
-
-// src/sync/run-sync.ts
-import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
-
-// src/sync/state-machine.ts
-function syncTransition(state, event) {
-  switch (state) {
-    case "pending":
-      if (event === "rebase_clean") return "synced";
-      if (event === "rebase_conflict") return "conflict";
-      if (event === "network_unavailable") return "offline";
-      break;
-    case "conflict":
-      if (event === "user_continue") return "synced";
-      if (event === "user_abort") return "aborted";
-      break;
-    case "offline":
-      if (event === "retry" || event === "rebase_clean") return "synced";
-      if (event === "rebase_conflict") return "conflict";
-      if (event === "network_unavailable") return "offline";
-      break;
-    case "synced":
-    case "aborted":
-      break;
-  }
-  throw new Error(`invalid sync transition: '${state}' --${event}-->`);
-}
-function planSync(stores) {
-  return { stores: stores.map((s) => ({ ...s, state: "pending" })) };
-}
-function applySyncEvent(session, alias, event) {
-  return {
-    stores: session.stores.map(
-      (s) => s.alias === alias ? { ...s, state: syncTransition(s.state, event) } : s
-    )
-  };
-}
-function continueSync(session) {
-  const conflicted = session.stores.find((s) => s.state === "conflict");
-  if (conflicted === void 0) {
-    throw new Error("`sync --continue` with no conflicted store to resume");
-  }
-  return applySyncEvent(session, conflicted.alias, "user_continue");
-}
-function abortSync(session) {
-  const conflicted = session.stores.find((s) => s.state === "conflict");
-  if (conflicted === void 0) {
-    throw new Error("`sync --abort` with no conflicted store to abort");
-  }
-  return applySyncEvent(session, conflicted.alias, "user_abort");
-}
-function isSyncSettled(session) {
-  return session.stores.every((s) => s.state !== "pending" && s.state !== "conflict");
-}
-function deferredPushStores(session) {
-  return session.stores.filter((s) => s.state === "offline");
-}
-
-// src/sync/run-sync.ts
-var NO_GLOBAL_CONFIG = "no global Fabric config \u2014 run `fabric install --global <url>` first";
-var NO_SESSION = "no sync in progress \u2014 run `fabric sync` first";
-var NO_CONFLICT = "no conflicted store to resume \u2014 sync is not paused";
-function syncSessionPath(globalRoot) {
-  return join(globalRoot, GLOBAL_STATE_DIR, "sync-session.json");
-}
-function loadSession(globalRoot) {
-  const path = syncSessionPath(globalRoot);
-  if (!existsSync(path)) {
-    return null;
-  }
-  return JSON.parse(readFileSync(path, "utf8"));
-}
-function saveSession(globalRoot, session) {
-  const path = syncSessionPath(globalRoot);
-  mkdirSync(join(path, ".."), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(session, null, 2)}
-`, "utf8");
-}
-function clearSession(globalRoot) {
-  rmSync(syncSessionPath(globalRoot), { force: true });
-}
-function defaultPull(storeDir) {
-  try {
-    execFileSync("git", ["pull", "--rebase"], {
-      cwd: storeDir,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return "clean";
-  } catch (error) {
-    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
-    if (/CONFLICT|could not apply|needs merge|rebase --continue/i.test(detail)) {
-      return "conflict";
-    }
-    if (/could not resolve host|could not read from remote|unable to access|connection|network is unreachable|timed out/i.test(
-      detail
-    )) {
-      return "offline";
-    }
-    throw error;
-  }
-}
-function gitErrText(error, key) {
-  const value = error[key];
-  return typeof value === "string" || Buffer.isBuffer(value) ? String(value) : "";
-}
-function defaultRebaseContinue(storeDir) {
-  execFileSync("git", ["rebase", "--continue"], { cwd: storeDir, stdio: "ignore" });
-}
-function defaultRebaseAbort(storeDir) {
-  execFileSync("git", ["rebase", "--abort"], { cwd: storeDir, stdio: "ignore" });
-}
-var OUTCOME_EVENT = {
-  clean: "rebase_clean",
-  conflict: "rebase_conflict",
-  offline: "network_unavailable"
-};
-function walkPending(session, storeDirOf, pull) {
-  let next = session;
-  for (const store of session.stores) {
-    if (store.state !== "pending") {
-      continue;
-    }
-    const outcome = pull(storeDirOf(store));
-    next = applySyncEvent(next, store.alias, OUTCOME_EVENT[outcome]);
-    if (outcome === "conflict") {
-      break;
-    }
-  }
-  return next;
-}
-function finalize(session, options, globalRoot) {
-  const settled = isSyncSettled(session);
-  let snapshotWritten = false;
-  if (settled) {
-    clearSession(globalRoot);
-    const snapshot = regenerateBindingsSnapshot(options.projectRoot, {
-      globalRoot,
-      now: options.now,
-      ...options.writeScope === void 0 ? {} : { writeScope: options.writeScope }
-    });
-    snapshotWritten = snapshot !== null;
-  } else {
-    saveSession(globalRoot, session);
-  }
-  return { session, settled, deferred: deferredPushStores(session), snapshotWritten };
-}
-function runStartSync(options) {
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const config = loadGlobalConfig(globalRoot);
-  if (config === null) {
-    throw new Error(NO_GLOBAL_CONFIG);
-  }
-  const syncable = config.stores.filter((store) => store.remote !== void 0);
-  const session = planSync(
-    syncable.map((store) => ({ alias: store.alias, store_uuid: store.store_uuid }))
-  );
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
-  const walked = walkPending(session, storeDirOf, options.pull ?? defaultPull);
-  return finalize(walked, options, globalRoot);
-}
-function runContinueSync(options) {
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const session = loadSession(globalRoot);
-  if (session === null) {
-    throw new Error(NO_SESSION);
-  }
-  const conflicted = session.stores.find((store) => store.state === "conflict");
-  if (conflicted === void 0) {
-    throw new Error(NO_CONFLICT);
-  }
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
-  (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
-  const resumed = walkPending(continueSync(session), storeDirOf, options.pull ?? defaultPull);
-  return finalize(resumed, options, globalRoot);
-}
-function runAbortSync(options) {
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const session = loadSession(globalRoot);
-  if (session === null) {
-    throw new Error(NO_SESSION);
-  }
-  const conflicted = session.stores.find((store) => store.state === "conflict");
-  if (conflicted === void 0) {
-    throw new Error(NO_CONFLICT);
-  }
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
-  (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
-  const resumed = walkPending(abortSync(session), storeDirOf, options.pull ?? defaultPull);
-  return finalize(resumed, options, globalRoot);
-}
-
-// src/commands/sync.ts
-function report(result) {
-  for (const store of result.session.stores) {
-    console.log(`${store.alias}	${store.state}`);
-  }
-  if (result.deferred.length > 0) {
-    console.log(
-      `${result.deferred.length} store(s) offline \u2014 push deferred; re-run \`fabric sync\` when online`
-    );
-  }
-  if (!result.settled) {
-    console.log(
-      "sync paused on a conflict \u2014 resolve it, then run `fabric sync --continue` (or `--abort`)"
-    );
-  }
-}
-var sync_default = defineCommand({
-  meta: { name: "sync", description: "Pull --rebase + push every mounted store; resume conflicts" },
-  args: {
-    continue: { type: "boolean", description: "Resume after resolving a rebase conflict" },
-    abort: { type: "boolean", description: "Abort the conflicted store's rebase" }
-  },
-  run({ args }) {
-    const options = { projectRoot: process.cwd(), now: (/* @__PURE__ */ new Date()).toISOString() };
-    if (args.continue === true) {
-      report(runContinueSync(options));
-      return;
-    }
-    if (args.abort === true) {
-      report(runAbortSync(options));
-      return;
-    }
-    report(runStartSync(options));
-  }
-});
-export {
-  sync_default as default
-};

package/dist/whoami-B6AEMSEV.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import {
-  whoami
-} from "./chunk-T5RPGCCM.js";
-import "./chunk-LFIKMVY7.js";
-import "./chunk-RYAFBNES.js";
-
-// src/commands/whoami.ts
-import { defineCommand } from "citty";
-var whoami_default = defineCommand({
-  meta: { name: "whoami", description: "Show this machine's Fabric uid and mounted stores" },
-  run() {
-    const info = whoami();
-    if (info === null) {
-      console.log("no global Fabric config \u2014 run `fabric install --global <url>` first");
-      return;
-    }
-    console.log(`uid: ${info.uid}`);
-    if (info.stores.length === 0) {
-      console.log("stores: (none mounted)");
-      return;
-    }
-    console.log("stores:");
-    for (const store of info.stores) {
-      console.log(`  ${store.alias}	${store.store_uuid}${store.local_only ? "	(local-only)" : ""}`);
-    }
-  }
-});
-export {
-  whoami_default as default
-};