@iowarp/clio-coder 0.3.0

package/dist/chunk-CLJ5HLUD.js

@@ -0,0 +1,458 @@
+import {
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+import {
+  clioConfigDir
+} from "./chunk-X3NE4WVW.js";
+
+// src/domains/extensions/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function trimString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateId(id) {
+  if (id.length > 80) return "id exceeds 80 characters";
+  if (!/^[a-z0-9][a-z0-9._-]*[a-z0-9]$/.test(id)) {
+    return "id must use lowercase letters, numbers, dots, underscores, or hyphens and start/end alphanumeric";
+  }
+  return null;
+}
+function readJsonOrYaml(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  if (filePath.endsWith(".json")) return JSON.parse(raw);
+  return parseYaml(raw);
+}
+function normalizeResources(value) {
+  if (!isRecord(value)) return {};
+  const out = {};
+  const skills = trimString(value.skills);
+  const prompts = trimString(value.prompts);
+  const themes = trimString(value.themes);
+  if (skills) out.skills = skills;
+  if (prompts) out.prompts = prompts;
+  if (themes) out.themes = themes;
+  return out;
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = value.map((entry) => trimString(entry)).filter((entry) => entry !== void 0);
+  return out.length > 0 ? out : void 0;
+}
+function parseExtensionManifest(value, manifestPath) {
+  const diagnostics = [];
+  if (!isRecord(value)) {
+    return { diagnostics: [{ type: "error", message: "extension manifest must be an object", path: manifestPath }] };
+  }
+  if (value.manifestVersion !== 1) {
+    diagnostics.push({ type: "error", message: "manifestVersion must be 1", path: manifestPath });
+  }
+  const id = trimString(value.id);
+  const name = trimString(value.name) ?? id;
+  const version = trimString(value.version);
+  const description = trimString(value.description);
+  if (!id) diagnostics.push({ type: "error", message: "id is required", path: manifestPath });
+  else {
+    const idError = validateId(id);
+    if (idError) diagnostics.push({ type: "error", message: idError, path: manifestPath });
+  }
+  if (!version) diagnostics.push({ type: "error", message: "version is required", path: manifestPath });
+  if (!description) diagnostics.push({ type: "error", message: "description is required", path: manifestPath });
+  const resources = normalizeResources(value.resources);
+  const tools = stringArray(value.tools);
+  const settings = stringArray(value.settings);
+  const compatibility = isRecord(value.compatibility) ? { ...trimString(value.compatibility.clio) ? { clio: trimString(value.compatibility.clio) } : {} } : void 0;
+  if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
+    return { diagnostics };
+  }
+  const manifest = {
+    manifestVersion: 1,
+    id,
+    name,
+    version,
+    description,
+    resources
+  };
+  if (tools) manifest.tools = tools;
+  if (settings) manifest.settings = settings;
+  if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
+  return { manifest, diagnostics };
+}
+function findExtensionManifestPath(root) {
+  for (const name of MANIFEST_NAMES) {
+    const candidate = path.join(root, name);
+    try {
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function loadManifestFromRoot(root) {
+  const manifestPath = findExtensionManifestPath(root);
+  if (!manifestPath) {
+    return {
+      path: root,
+      valid: false,
+      diagnostics: [{ type: "error", message: "extension manifest not found", path: root }]
+    };
+  }
+  try {
+    const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
+    return {
+      path: root,
+      manifestPath,
+      ...parsed.manifest ? { manifest: parsed.manifest } : {},
+      valid: parsed.manifest !== void 0 && !parsed.diagnostics.some((diag) => diag.type === "error"),
+      diagnostics: parsed.diagnostics
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      path: root,
+      manifestPath,
+      valid: false,
+      diagnostics: [{ type: "error", message: `extension manifest could not be read: ${reason}`, path: manifestPath }]
+    };
+  }
+}
+function discoverExtensionPackages(root) {
+  const full = path.resolve(root);
+  if (!existsSync(full)) {
+    return [{ path: full, valid: false, diagnostics: [{ type: "error", message: "path does not exist", path: full }] }];
+  }
+  const stat = statSync(full);
+  if (!stat.isDirectory()) {
+    return [
+      {
+        path: full,
+        valid: false,
+        diagnostics: [{ type: "error", message: "extension path is not a directory", path: full }]
+      }
+    ];
+  }
+  const direct = loadManifestFromRoot(full);
+  if (direct.valid || direct.manifestPath) return [direct];
+  const candidates = [];
+  for (const entry of readdirSync(full, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const child = path.join(full, entry.name);
+    const loaded = loadManifestFromRoot(child);
+    if (loaded.valid || loaded.manifestPath) candidates.push(loaded);
+  }
+  const discovered = candidates.length > 0 ? candidates : [direct];
+  const ids = /* @__PURE__ */ new Map();
+  for (const candidate of discovered) {
+    const id = candidate.manifest?.id;
+    if (!id) continue;
+    const group = ids.get(id) ?? [];
+    group.push(candidate);
+    ids.set(id, group);
+  }
+  for (const [id, group] of ids) {
+    if (group.length < 2) continue;
+    for (const candidate of group) {
+      candidate.valid = false;
+      candidate.diagnostics.push({
+        type: "error",
+        message: `duplicate extension id ${id}`,
+        path: candidate.manifestPath ?? candidate.path
+      });
+    }
+  }
+  return discovered;
+}
+
+// src/domains/extensions/state.ts
+import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, renameSync, rmSync } from "node:fs";
+import path2 from "node:path";
+var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
+function extensionBaseDir(scope, cwd = process.cwd()) {
+  return scope === "user" ? path2.join(clioConfigDir(), "extensions") : path2.join(path2.resolve(cwd), ".clio-coder", "extensions");
+}
+function statePath(scope, cwd = process.cwd()) {
+  return path2.join(extensionBaseDir(scope, cwd), "state.json");
+}
+function scopeRank(scope) {
+  return scope === "project" ? 2 : 1;
+}
+function readState(scope, cwd = process.cwd()) {
+  const filePath = statePath(scope, cwd);
+  if (!existsSync2(filePath)) return structuredClone(DEFAULT_STATE);
+  try {
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    if (!isRecord(parsed) || parsed.version !== 1) return structuredClone(DEFAULT_STATE);
+    const disabled = Array.isArray(parsed.disabled) ? parsed.disabled.filter((entry) => typeof entry === "string") : [];
+    const installed = isRecord(parsed.installed) ? Object.fromEntries(
+      Object.entries(parsed.installed).flatMap(([id, raw]) => {
+        if (!isRecord(raw)) return [];
+        const installedAt = trimString(raw.installedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+        const source = trimString(raw.source);
+        return [[id, { installedAt, ...source ? { source } : {} }]];
+      })
+    ) : {};
+    return { version: 1, disabled, installed };
+  } catch {
+    return structuredClone(DEFAULT_STATE);
+  }
+}
+function writeState(scope, state, cwd = process.cwd()) {
+  const filePath = statePath(scope, cwd);
+  safeResourceWrite(filePath, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8" });
+}
+function installedFromRoot(root, scope, state) {
+  const candidate = loadManifestFromRoot(root);
+  const manifest = candidate.manifest;
+  if (!manifest || !candidate.manifestPath) return null;
+  return {
+    id: manifest.id,
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description,
+    scope,
+    rootPath: root,
+    manifestPath: candidate.manifestPath,
+    enabled: !state.disabled.includes(manifest.id),
+    effective: false,
+    resources: manifest.resources,
+    diagnostics: candidate.diagnostics
+  };
+}
+function listScope(scope, cwd = process.cwd()) {
+  const base = extensionBaseDir(scope, cwd);
+  if (!existsSync2(base)) return [];
+  const state = readState(scope, cwd);
+  const out = [];
+  for (const entry of readdirSync2(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    const root = path2.join(base, entry.name);
+    const installed = installedFromRoot(root, scope, state);
+    if (installed) out.push(installed);
+  }
+  return out;
+}
+function listInstalledExtensions(cwd = process.cwd(), options = {}) {
+  const scopes = options.scope ? [options.scope] : ["user", "project"];
+  const entries = scopes.flatMap((scope) => listScope(scope, cwd));
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = byId.get(entry.id) ?? [];
+    list.push(entry);
+    byId.set(entry.id, list);
+  }
+  for (const group of byId.values()) {
+    const winner = [...group].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
+    for (const entry of group) {
+      entry.effective = entry === winner;
+      if (!entry.effective && winner) entry.overriddenBy = winner.scope;
+    }
+  }
+  const all = options.all === true ? entries : entries.filter((entry) => entry.effective);
+  return all.sort((a, b) => {
+    const id = a.id.localeCompare(b.id);
+    if (id !== 0) return id;
+    return scopeRank(a.scope) - scopeRank(b.scope);
+  });
+}
+function findInstalled(id, cwd, scope) {
+  const entries = listInstalledExtensions(cwd, { ...scope ? { scope } : {}, all: true }).filter(
+    (entry) => entry.id === id
+  );
+  if (entries.length === 0) return null;
+  return [...entries].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1) ?? null;
+}
+function installExtension(sourcePath, options = {}) {
+  const scope = options.scope ?? "user";
+  const cwd = options.cwd ?? process.cwd();
+  const source = path2.resolve(sourcePath);
+  const candidate = loadManifestFromRoot(source);
+  if (!candidate.manifest) return { diagnostics: candidate.diagnostics };
+  const targetRoot = path2.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
+  if (existsSync2(targetRoot)) {
+    if (!options.force) {
+      return {
+        diagnostics: [
+          { type: "error", message: `extension ${candidate.manifest.id} is already installed`, path: targetRoot }
+        ]
+      };
+    }
+  }
+  const parent = path2.dirname(targetRoot);
+  const stagingRoot = path2.join(parent, `.${candidate.manifest.id}.install-${process.pid}-${Date.now()}`);
+  const backupRoot = path2.join(parent, `.${candidate.manifest.id}.backup-${process.pid}-${Date.now()}`);
+  let installedReplacement = false;
+  let movedExisting = false;
+  const state = readState(scope, cwd);
+  try {
+    mkdirSync(parent, { recursive: true });
+    rmSync(stagingRoot, { recursive: true, force: true });
+    rmSync(backupRoot, { recursive: true, force: true });
+    cpSync(source, stagingRoot, {
+      recursive: true,
+      filter: (src) => path2.basename(src) !== "state.json"
+    });
+    if (existsSync2(targetRoot)) {
+      renameSync(targetRoot, backupRoot);
+      movedExisting = true;
+    }
+    renameSync(stagingRoot, targetRoot);
+    installedReplacement = true;
+    state.installed[candidate.manifest.id] = { installedAt: (/* @__PURE__ */ new Date()).toISOString(), source };
+    state.disabled = state.disabled.filter((entry) => entry !== candidate.manifest?.id);
+    writeState(scope, state, cwd);
+    rmSync(backupRoot, { recursive: true, force: true });
+  } catch (error) {
+    rmSync(stagingRoot, { recursive: true, force: true });
+    if (installedReplacement) rmSync(targetRoot, { recursive: true, force: true });
+    if (movedExisting && existsSync2(backupRoot) && !existsSync2(targetRoot)) {
+      renameSync(backupRoot, targetRoot);
+    }
+    return {
+      diagnostics: [
+        {
+          type: "error",
+          message: `extension ${candidate.manifest.id} install failed: ${error instanceof Error ? error.message : String(error)}`,
+          path: targetRoot
+        }
+      ]
+    };
+  }
+  const installed = findInstalled(candidate.manifest.id, cwd, scope);
+  return {
+    ...installed ? { extension: installed } : {},
+    diagnostics: candidate.diagnostics
+  };
+}
+function mutateEnabled(id, enabled, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const target = findInstalled(id, cwd, options.scope);
+  if (!target) {
+    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
+  }
+  const state = readState(target.scope, cwd);
+  if (enabled) state.disabled = state.disabled.filter((entry) => entry !== id);
+  else if (!state.disabled.includes(id)) state.disabled.push(id);
+  writeState(target.scope, state, cwd);
+  const extension = findInstalled(id, cwd, target.scope) ?? void 0;
+  return { ...extension ? { extension } : {}, diagnostics: [] };
+}
+function enableExtension(id, options = {}) {
+  return mutateEnabled(id, true, options);
+}
+function disableExtension(id, options = {}) {
+  return mutateEnabled(id, false, options);
+}
+function removeExtension(id, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const target = findInstalled(id, cwd, options.scope);
+  if (!target) {
+    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
+  }
+  rmSync(target.rootPath, { recursive: true, force: true });
+  const state = readState(target.scope, cwd);
+  Reflect.deleteProperty(state.installed, id);
+  state.disabled = state.disabled.filter((entry) => entry !== id);
+  writeState(target.scope, state, cwd);
+  return { removed: { id, scope: target.scope, path: target.rootPath }, diagnostics: [] };
+}
+
+// src/domains/extensions/resources.ts
+import { statSync as statSync2 } from "node:fs";
+import path3 from "node:path";
+function extensionResourcePath(rootPath, resourcePath) {
+  const root = path3.resolve(rootPath);
+  const full = path3.resolve(root, resourcePath);
+  const relative = path3.relative(root, full);
+  if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) return full;
+  return null;
+}
+function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
+  const roots = [];
+  for (const entry of listInstalledExtensions(cwd)) {
+    if (!entry.enabled || !entry.effective) continue;
+    const rel = entry.resources[kind];
+    if (!rel) continue;
+    const full = extensionResourcePath(entry.rootPath, rel);
+    if (!full) continue;
+    try {
+      if (!statSync2(full).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    roots.push({
+      id: entry.id,
+      scope: entry.scope,
+      path: full,
+      source: `extension:${entry.scope}:${entry.id}`
+    });
+  }
+  return roots;
+}
+
+// src/domains/extensions/extension.ts
+function createExtensionsBundle(_context) {
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    list(cwd, options = {}) {
+      return listInstalledExtensions(cwd, options);
+    },
+    discover(root) {
+      return discoverExtensionPackages(root);
+    },
+    install(root, options = {}) {
+      return installExtension(root, options);
+    },
+    enable(id, options = {}) {
+      return enableExtension(id, options);
+    },
+    disable(id, options = {}) {
+      return disableExtension(id, options);
+    },
+    remove(id, options = {}) {
+      return removeExtension(id, options);
+    },
+    resourceRoots(kind, cwd) {
+      return enabledExtensionResourceRoots(kind, cwd);
+    },
+    async reload() {
+      return void 0;
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/extensions/manifest.ts
+var ExtensionsManifest = {
+  name: "extensions",
+  dependsOn: ["config"]
+};
+
+// src/domains/extensions/index.ts
+var ExtensionsDomainModule = {
+  manifest: ExtensionsManifest,
+  createExtension: createExtensionsBundle
+};
+
+export {
+  discoverExtensionPackages,
+  listInstalledExtensions,
+  installExtension,
+  enableExtension,
+  disableExtension,
+  removeExtension,
+  enabledExtensionResourceRoots,
+  ExtensionsDomainModule
+};
+//# sourceMappingURL=chunk-CLJ5HLUD.js.map

package/dist/chunk-D5YD55AR.js

@@ -0,0 +1,116 @@
+// src/core/bus-events.ts
+var BusChannels = {
+  SessionStart: "session.start",
+  SessionEnd: "session.end",
+  SessionParked: "session.parked",
+  SessionResumed: "session.resumed",
+  DomainLoaded: "domain.loaded",
+  DomainFailed: "domain.failed",
+  ConfigHotReload: "config.hotReload",
+  ConfigNextTurn: "config.nextTurn",
+  ConfigRestartRequired: "config.restartRequired",
+  ConfigReloadFailed: "config.reloadFailed",
+  PermissionRequested: "permission.requested",
+  PermissionResolved: "permission.resolved",
+  SafetyClassified: "safety.classified",
+  SafetyBlocked: "safety.blocked",
+  SafetyAllowed: "safety.allowed",
+  LoopBlocked: "safety.loopBlocked",
+  ToolBudgetExceeded: "safety.toolBudgetExceeded",
+  ProviderHealth: "provider.health",
+  RuntimeNotice: "runtime.notice",
+  DispatchEnqueued: "dispatch.enqueued",
+  DispatchStarted: "dispatch.started",
+  DispatchProgress: "dispatch.progress",
+  DispatchCompleted: "dispatch.completed",
+  DispatchFailed: "dispatch.failed",
+  CompactionBegin: "compaction.begin",
+  CompactionEnd: "compaction.end",
+  MiddlewareHookFailed: "middleware.hookFailed",
+  ContextActivity: "context.activity",
+  ContextWarning: "context.warning",
+  ContextPruned: "context.pruned",
+  AgentStatusChanged: "agent.status.changed",
+  RunAborted: "run.aborted",
+  BudgetAlert: "budget.alert",
+  ShutdownRequested: "shutdown.requested",
+  ShutdownDrained: "shutdown.drained",
+  ShutdownTerminated: "shutdown.terminated",
+  ShutdownPersisted: "shutdown.persisted"
+};
+var RUN_ABORT_SOURCES = /* @__PURE__ */ new Set([
+  "dispatch_abort",
+  "dispatch_drain",
+  "stream_cancel",
+  "loop_guard"
+]);
+function isRunAbortedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (typeof p.source !== "string" || !RUN_ABORT_SOURCES.has(p.source)) return false;
+  if (p.runId !== null && typeof p.runId !== "string") return false;
+  if (p.startedAt !== null && typeof p.startedAt !== "string") return false;
+  if (p.elapsedMs !== null && typeof p.elapsedMs !== "number") return false;
+  if (p.reason !== void 0 && typeof p.reason !== "string") return false;
+  return true;
+}
+
+// src/core/event-bus.ts
+function reportListenerError(channel, error) {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.error(`[clio:event-bus] Listener crashed on ${channel}: ${message}`);
+}
+function createSafeEventBus() {
+  const registry = /* @__PURE__ */ new Map();
+  const deliver = (channel, payload) => {
+    const ls = registry.get(channel);
+    if (!ls) return;
+    for (const listener of [...ls]) {
+      try {
+        const result = listener(payload);
+        if (result && typeof result.then === "function") {
+          result.catch((error) => reportListenerError(channel, error));
+        }
+      } catch (error) {
+        reportListenerError(channel, error);
+      }
+    }
+  };
+  const bus = {
+    emit(channel, payload) {
+      deliver(channel, payload);
+    },
+    on(channel, listener) {
+      const set = registry.get(channel) ?? /* @__PURE__ */ new Set();
+      set.add(listener);
+      registry.set(channel, set);
+      return () => {
+        const current = registry.get(channel);
+        if (!current) return;
+        current.delete(listener);
+        if (current.size === 0) registry.delete(channel);
+      };
+    },
+    listeners(channel) {
+      return [...registry.get(channel) ?? []];
+    },
+    clear() {
+      registry.clear();
+    }
+  };
+  return bus;
+}
+
+// src/core/shared-bus.ts
+var sharedBus = null;
+function getSharedBus() {
+  if (!sharedBus) sharedBus = createSafeEventBus();
+  return sharedBus;
+}
+
+export {
+  BusChannels,
+  isRunAbortedPayload,
+  getSharedBus
+};
+//# sourceMappingURL=chunk-D5YD55AR.js.map

package/dist/chunk-DXQNI4PC.js

@@ -0,0 +1,61 @@
+// src/core/package-root.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/engine/pi-mono-names.ts
+var PI_MONO_PACKAGES = {
+  agentCore: "@earendil-works/pi-agent-core",
+  ai: "@earendil-works/pi-ai",
+  tui: "@earendil-works/pi-tui"
+};
+
+// src/core/package-root.ts
+var cached = null;
+var cachedClioVersion = null;
+var cachedPiMonoVersion = null;
+function resolvePackageRoot(metaUrl = import.meta.url) {
+  if (cached) return cached;
+  const override = process.env.CLIO_CODER_PACKAGE_ROOT?.trim();
+  if (override) {
+    cached = resolve(override);
+    return cached;
+  }
+  let dir = resolve(dirname(fileURLToPath(metaUrl)));
+  while (true) {
+    if (existsSync(join(dir, "package.json"))) {
+      cached = dir;
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not find package.json above ${dir}`);
+    }
+    dir = parent;
+  }
+}
+function readPackageJson() {
+  const root = resolvePackageRoot();
+  const raw = readFileSync(join(root, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function readClioVersion() {
+  if (cachedClioVersion) return cachedClioVersion;
+  const pkg = readPackageJson();
+  cachedClioVersion = pkg.version ?? "0.0.0";
+  return cachedClioVersion;
+}
+function readPiMonoVersion() {
+  if (cachedPiMonoVersion) return cachedPiMonoVersion;
+  const pkg = readPackageJson();
+  cachedPiMonoVersion = pkg.dependencies?.[PI_MONO_PACKAGES.agentCore] ?? "unknown";
+  return cachedPiMonoVersion;
+}
+
+export {
+  PI_MONO_PACKAGES,
+  resolvePackageRoot,
+  readClioVersion,
+  readPiMonoVersion
+};
+//# sourceMappingURL=chunk-DXQNI4PC.js.map