@iowarp/clio-coder 0.4.1 → 0.4.2

package/dist/chunk-HLAFFSEK.js

@@ -0,0 +1,360 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  disableExtension,
+  discoverExtensionPackages,
+  enableExtension,
+  installExtension,
+  listInstalledExtensionRecords,
+  listInstalledExtensions,
+  removeExtension
+} from "./chunk-77QIVUZB.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/extensions/manager.ts
+init_esm_shims();
+
+// src/domains/extensions/resources.ts
+init_esm_shims();
+import { realpathSync as realpathSync3 } from "node:fs";
+import path3 from "node:path";
+
+// src/domains/extensions/snapshot.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { realpathSync as realpathSync2 } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/extensions/resource-path.ts
+init_esm_shims();
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+function extensionResourcePath(rootPath, resourcePath) {
+  const root = path.resolve(rootPath);
+  const full = path.resolve(root, resourcePath);
+  const relative = path.relative(root, full);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  try {
+    const rootReal = realpathSync(root);
+    const fullReal = realpathSync(full);
+    const canonicalRelative = path.relative(rootReal, fullReal);
+    if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(canonicalRelative)) {
+      return null;
+    }
+    if (!statSync(fullReal).isDirectory()) return null;
+    return fullReal;
+  } catch {
+    return null;
+  }
+}
+
+// src/domains/extensions/types.ts
+init_esm_shims();
+function isLoadableExtension(entry) {
+  return entry.loadable && entry.provenance !== void 0;
+}
+
+// src/domains/extensions/snapshot.ts
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_CAP = 200;
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_PER_PACKAGE_CAP = 20;
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP = 512;
+var RESOURCE_KINDS = ["skills", "prompts", "agents", "fleets", "themes"];
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) deepFreeze(child, seen);
+  return Object.freeze(value);
+}
+function boundedDiagnostics(records) {
+  const entries = [];
+  let truncated = 0;
+  for (const { entry } of records) {
+    let admittedForPackage = 0;
+    for (const diagnostic of entry.diagnostics) {
+      if (admittedForPackage >= EXTENSION_SNAPSHOT_DIAGNOSTIC_PER_PACKAGE_CAP || entries.length >= EXTENSION_SNAPSHOT_DIAGNOSTIC_CAP) {
+        truncated += 1;
+        continue;
+      }
+      entries.push({
+        type: diagnostic.type,
+        message: diagnostic.message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP),
+        ...diagnostic.path ? { path: diagnostic.path } : {},
+        extensionId: entry.id
+      });
+      admittedForPackage += 1;
+    }
+  }
+  return { entries, truncated };
+}
+function buildExtensionSnapshot(input) {
+  const cwd = realpathSync2(path2.resolve(input.cwd));
+  const records = (input.listRecords ?? listInstalledExtensionRecords)(cwd, { all: true });
+  const resourceRoots = {
+    skills: [],
+    prompts: [],
+    agents: [],
+    fleets: [],
+    themes: []
+  };
+  const hookSources = [];
+  const digestPackages = [];
+  for (const record of records) {
+    const { entry } = record;
+    const packageRoots = [];
+    let hooksDigest;
+    if (isLoadableExtension(entry)) {
+      for (const kind of RESOURCE_KINDS) {
+        const relative = entry.resources[kind];
+        if (!relative) continue;
+        const resolved = extensionResourcePath(entry.rootPath, relative);
+        if (!resolved) continue;
+        resourceRoots[kind].push({
+          id: entry.id,
+          scope: entry.scope,
+          path: resolved,
+          rootPath: entry.rootPath,
+          source: `extension:${entry.scope}:${entry.id}`,
+          provenance: entry.provenance,
+          generation: input.generation
+        });
+        packageRoots.push({ kind, path: resolved });
+      }
+      const hookBytes = record.captured?.get("hooks.yaml");
+      if (hookBytes !== void 0) {
+        hooksDigest = createHash("sha256").update(hookBytes).digest("hex");
+        let declarations = [];
+        let parseError;
+        try {
+          declarations = (0, import_yaml.parse)(hookBytes.toString("utf8")) ?? [];
+        } catch (error) {
+          parseError = error instanceof Error ? error.message : String(error);
+        }
+        hookSources.push({
+          provenance: entry.provenance,
+          declarationsDigest: hooksDigest,
+          declarations,
+          ...parseError ? { parseError } : {}
+        });
+      }
+    }
+    digestPackages.push({
+      id: entry.id,
+      scope: entry.scope,
+      loadable: entry.loadable,
+      ...entry.provenance ? { provenance: entry.provenance } : {},
+      resourceRoots: packageRoots,
+      ...hooksDigest ? { hooksDigest } : {}
+    });
+  }
+  const snapshot = {
+    version: 1,
+    generation: input.generation,
+    cwd,
+    builtAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    digest: createHash("sha256").update(canonicalJson(digestPackages)).digest("hex"),
+    packages: records.map((record) => record.entry),
+    resourceRoots,
+    hookSources,
+    diagnostics: boundedDiagnostics(records)
+  };
+  return deepFreeze(snapshot);
+}
+function packageFingerprints(snapshot) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.packages) {
+    const list = grouped.get(entry.id) ?? [];
+    list.push({
+      scope: entry.scope,
+      loadable: entry.loadable,
+      provenance: entry.provenance ?? null,
+      resources: entry.resources
+    });
+    grouped.set(entry.id, list);
+  }
+  return new Map(
+    [...grouped].map(([id, values]) => [id, createHash("sha256").update(canonicalJson(values)).digest("hex")])
+  );
+}
+function diffExtensionSnapshots(previous, next) {
+  if (previous === null) {
+    return { changed: true, added: [...new Set(next.packages.map((entry) => entry.id))], removed: [], modified: [] };
+  }
+  const before = packageFingerprints(previous);
+  const after = packageFingerprints(next);
+  const added = [...after.keys()].filter((id) => !before.has(id));
+  const removed = [...before.keys()].filter((id) => !after.has(id));
+  const modified = [...after.keys()].filter((id) => before.has(id) && before.get(id) !== after.get(id));
+  return { changed: previous.digest !== next.digest, added, removed, modified };
+}
+
+// src/domains/extensions/snapshot-store.ts
+init_esm_shims();
+function createExtensionSnapshotStore() {
+  let committed = null;
+  let reservedGeneration = 0;
+  return {
+    current: () => committed,
+    publish(snapshot) {
+      committed = snapshot;
+    },
+    nextGeneration() {
+      reservedGeneration += 1;
+      return reservedGeneration;
+    }
+  };
+}
+var boundStore = null;
+function committedExtensionSnapshot() {
+  return boundStore?.current() ?? null;
+}
+function bindExtensionSnapshotStore(store) {
+  boundStore = store;
+}
+
+// src/domains/extensions/resources.ts
+function extensionSnapshotFor(cwd = process.cwd()) {
+  const committed = committedExtensionSnapshot();
+  try {
+    if (committed !== null && committed.cwd === realpathSync3(path3.resolve(cwd))) return committed;
+  } catch {
+  }
+  return buildExtensionSnapshot({ cwd, generation: 0 });
+}
+function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
+  return [...extensionSnapshotFor(cwd).resourceRoots[kind]];
+}
+
+// src/domains/extensions/index.ts
+init_esm_shims();
+
+// src/domains/extensions/extension.ts
+init_esm_shims();
+function failureDiagnostics(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    entries: [{ type: "error", message: message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP) }],
+    truncated: 0
+  };
+}
+function createExtensionsBundle(_context, options = {}) {
+  const store = createExtensionSnapshotStore();
+  const cwd = options.cwd ?? (() => process.cwd());
+  const build = (generation) => buildExtensionSnapshot({
+    cwd: cwd(),
+    generation,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.listRecords !== void 0 ? { listRecords: options.listRecords } : {}
+  });
+  let inFlight = null;
+  const rejected = (reason, diagnostics) => ({
+    status: "rejected",
+    reason,
+    generation: store.current()?.generation ?? 0,
+    diagnostics
+  });
+  const extension = {
+    start() {
+      bindExtensionSnapshotStore(store);
+    },
+    stop() {
+      inFlight = null;
+      bindExtensionSnapshotStore(null);
+    }
+  };
+  const contract = {
+    list(cwd2, options2 = {}) {
+      return listInstalledExtensions(cwd2, options2);
+    },
+    discover(root) {
+      return discoverExtensionPackages(root);
+    },
+    install(root, options2 = {}) {
+      return installExtension(root, options2);
+    },
+    enable(id, options2 = {}) {
+      return enableExtension(id, options2);
+    },
+    disable(id, options2 = {}) {
+      return disableExtension(id, options2);
+    },
+    remove(id, options2 = {}) {
+      return removeExtension(id, options2);
+    },
+    resourceRoots(kind, requestedCwd) {
+      return enabledExtensionResourceRoots(kind, requestedCwd ?? cwd());
+    },
+    snapshot() {
+      return store.current();
+    },
+    generation() {
+      return store.current()?.generation ?? 0;
+    },
+    prepareReload() {
+      if (inFlight !== null) return rejected("reentrant", { entries: [], truncated: 0 });
+      const previous = store.current();
+      const generation = store.nextGeneration();
+      let snapshot;
+      try {
+        snapshot = build(generation);
+      } catch (error) {
+        return rejected("build-failed", failureDiagnostics(error));
+      }
+      const candidate = {
+        generation,
+        previousGeneration: previous?.generation ?? 0,
+        snapshot,
+        ...diffExtensionSnapshots(previous, snapshot),
+        // Identity on the committed reference covers every intervening
+        // publish; the in-flight check covers discard and double publish.
+        current: () => inFlight === candidate && store.current() === previous,
+        publish() {
+          store.publish(snapshot);
+          inFlight = null;
+        },
+        discard() {
+          if (inFlight === candidate) inFlight = null;
+        }
+      };
+      inFlight = candidate;
+      return { status: "prepared", candidate };
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/extensions/manifest.ts
+init_esm_shims();
+var ExtensionsManifest = {
+  name: "extensions",
+  dependsOn: ["config"]
+};
+
+// src/domains/extensions/index.ts
+var ExtensionsDomainModule = {
+  manifest: ExtensionsManifest,
+  createExtension: createExtensionsBundle
+};
+
+export {
+  EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP,
+  extensionSnapshotFor,
+  enabledExtensionResourceRoots,
+  ExtensionsDomainModule
+};
+//# sourceMappingURL=chunk-HLAFFSEK.js.map

package/dist/{chunk-UAPGZHYC.js → chunk-I64IFBLB.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   combineBashOutput
-} from "./chunk-U2WB7TZS.js";
+} from "./chunk-NMJXSHBJ.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1981,6 +1981,13 @@ var CLIO_APP_KEYBINDINGS = {
     defaultKeys: "alt+w",
     description: "Toggle the dispatch (workers) board overlay"
   },
+  "clio-coder.files.toggle": {
+    // Alt+F is a pi-tui editor reserve (word-forward), so the files pane
+    // takes the next letter that reads as "explorer" and stays inside the
+    // Alt+<letter> scheme, which also earns it the Ctrl+G leader fallback.
+    defaultKeys: "alt+e",
+    description: "Toggle the files pane beside the session (a --with-panes session inside herdr)"
+  },
   "clio-coder.tasks.open": {
     // Approved application-boundary override of pi-tui editor word-back.
     defaultKeys: "alt+b",
@@ -2490,4 +2497,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-UAPGZHYC.js.map
+//# sourceMappingURL=chunk-I64IFBLB.js.map