@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-T6YILFSB.js

@@ -0,0 +1,80 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/skill-activation.ts
+init_esm_shims();
+var SKILL_SUGGESTION_ANCHOR = "Suggested skill: /skill <name>";
+var SKILL_SUGGESTION_PREFIX = SKILL_SUGGESTION_ANCHOR.slice(0, SKILL_SUGGESTION_ANCHOR.indexOf("<name>"));
+var SKILL_SURFACE_EXEMPT_TOOLS = /* @__PURE__ */ new Set(["context", "ask_user"]);
+function evaluateSkillToolSurface(policy, tool) {
+  if (!policy || policy.loadedSkillPolicies.size === 0) return null;
+  if (SKILL_SURFACE_EXEMPT_TOOLS.has(tool)) return null;
+  const entries = [...policy.loadedSkillPolicies.entries()];
+  const skills = entries.map(([name]) => name);
+  const disallowedBy = entries.filter(([, declared]) => declared.disallowedTools?.includes(tool) === true).map(([name]) => name);
+  if (disallowedBy.length > 0) return { skills, mergedAllowedTools: null, disallowedBy };
+  const allowLists = entries.map(([, declared]) => declared.allowedTools);
+  if (allowLists.some((list) => list === void 0 || list.length === 0)) return null;
+  const merged = [...new Set(allowLists.flatMap((list) => [...list ?? []]))];
+  if (merged.includes(tool)) return null;
+  return { skills, mergedAllowedTools: merged, disallowedBy: [] };
+}
+function agentSkillToolPolicy(skillNames) {
+  const allowedSkillNames = [...new Set(skillNames.map((name) => name.trim()).filter((name) => name.length > 0))];
+  if (allowedSkillNames.length === 0) return void 0;
+  return {
+    allowedSkillNames,
+    requests: allowedSkillNames.map((name) => ({ name, args: "", source: "recipe", installed: true })),
+    loadedSkillNames: /* @__PURE__ */ new Set(),
+    loadedSkillPolicies: /* @__PURE__ */ new Map()
+  };
+}
+function trimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function skillActivationFromSource(source, triggeredBy, turnId) {
+  const sourceOrigin = trimmedString(source.sourceOrigin) ?? trimmedString(source.sourceInfo?.source);
+  return {
+    name: source.name,
+    filePath: source.filePath,
+    hash: source.hash,
+    source: source.source,
+    ...sourceOrigin ? { sourceOrigin } : {},
+    triggeredBy,
+    ...turnId ? { turnId } : {}
+  };
+}
+function skillActivationFromToolDetails(details, turnId) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return null;
+  const record = details;
+  const name = trimmedString(record.name);
+  const filePath = trimmedString(record.filePath) ?? trimmedString(record.path);
+  const hash = trimmedString(record.hash);
+  const source = trimmedString(record.source);
+  const sourceOrigin = trimmedString(record.sourceOrigin) ?? trimmedString(record.origin);
+  if (!name || !filePath || !hash || !source) return null;
+  const activation = skillActivationFromSource(
+    { name, filePath, hash, source, ...sourceOrigin ? { sourceOrigin } : {} },
+    "tool",
+    turnId
+  );
+  if (record.drift === "match" || record.drift === "mismatch") activation.drift = record.drift;
+  return activation;
+}
+function isSkillActivation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.name === "string" && typeof record.filePath === "string" && typeof record.hash === "string" && typeof record.source === "string" && (record.sourceOrigin === void 0 || typeof record.sourceOrigin === "string") && (record.triggeredBy === "slash-command" || record.triggeredBy === "tool") && (record.turnId === void 0 || typeof record.turnId === "string") && (record.runId === void 0 || typeof record.runId === "string");
+}
+
+export {
+  SKILL_SUGGESTION_ANCHOR,
+  SKILL_SUGGESTION_PREFIX,
+  evaluateSkillToolSurface,
+  agentSkillToolPolicy,
+  skillActivationFromToolDetails,
+  isSkillActivation
+};
+//# sourceMappingURL=chunk-T6YILFSB.js.map

package/dist/chunk-TZTZS7QK.js

@@ -0,0 +1,227 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  BusChannels,
+  getSharedBus
+} from "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/termination.ts
+init_esm_shims();
+var DEFAULT_SHUTDOWN_HOOK_MS = 500;
+var SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143
+};
+function wrapToWidth(text, width) {
+  if (!Number.isFinite(width) || width < 1) return [text];
+  const lines = [];
+  let current = "";
+  for (const word of text.split(/\s+/).filter((w) => w.length > 0)) {
+    let token = word;
+    while (token.length > width) {
+      if (current) {
+        lines.push(current);
+        current = "";
+      }
+      lines.push(token.slice(0, width));
+      token = token.slice(width);
+    }
+    if (!current) current = token;
+    else if (current.length + 1 + token.length <= width) current = `${current} ${token}`;
+    else {
+      lines.push(current);
+      current = token;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [""];
+}
+function writeShutdownNotice(text) {
+  const width = process.stderr.columns ?? process.stdout.columns;
+  const lines = width === void 0 ? [text] : wrapToWidth(text, width);
+  process.stderr.write(`${lines.join("\n")}
+`);
+}
+function resolveShutdownHookBudgetMs() {
+  const raw = process.env.CLIO_CODER_SHUTDOWN_HOOK_MS;
+  if (raw === void 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  return parsed;
+}
+async function runWithBudget(op, budgetMs, onError) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), budgetMs);
+  });
+  try {
+    const done = Promise.resolve().then(() => op()).then(() => "done").catch((err) => {
+      onError?.(err);
+      return "done";
+    });
+    const outcome = await Promise.race([done, timeout]);
+    return outcome === "done";
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var TerminationCoordinator = class {
+  phase = "idle";
+  drainHooks = [];
+  terminateHooks = [];
+  persistHooks = [];
+  exitCode = 0;
+  started = false;
+  drained = false;
+  pendingNotices = [];
+  signalHandler = null;
+  getPhase() {
+    return this.phase;
+  }
+  /**
+   * The process exit code this shutdown will use. Set before any hook runs,
+   * so a hook sealing terminal accounting records the same status the process
+   * reports (130 for SIGINT, 143 for SIGTERM).
+   */
+  getExitCode() {
+    return this.exitCode;
+  }
+  onDrain(hook) {
+    this.drainHooks.push(hook);
+  }
+  onTerminate(hook) {
+    this.terminateHooks.push(hook);
+  }
+  onPersist(hook) {
+    this.persistHooks.push(hook);
+  }
+  async shutdown(code = 0) {
+    if (this.started) return;
+    this.started = true;
+    this.exitCode = code;
+    const bus = getSharedBus();
+    const debug = process.env.CLIO_CODER_DEBUG_SHUTDOWN === "1";
+    const budgetMs = resolveShutdownHookBudgetMs();
+    const mark = debug ? process.hrtime.bigint() : 0n;
+    const log = (msg) => {
+      if (!debug) return;
+      const ms = Number(process.hrtime.bigint() - mark) / 1e6;
+      process.stderr.write(`[clio:shutdown] +${ms.toFixed(1)}ms ${msg}
+`);
+    };
+    this.phase = "draining";
+    bus.emit(BusChannels.ShutdownRequested, { phase: this.phase });
+    log("drain:start");
+    await this.runHooks(this.drainHooks, "drain", budgetMs, log);
+    log("drain:end");
+    this.drained = true;
+    this.flushNotices();
+    bus.emit(BusChannels.ShutdownDrained, {});
+    this.phase = "terminating";
+    log("terminate:start");
+    await this.runHooks(this.terminateHooks, "terminate", budgetMs, log);
+    log("terminate:end");
+    bus.emit(BusChannels.ShutdownTerminated, {});
+    this.phase = "persisting";
+    log("persist:start");
+    await this.runHooks(this.persistHooks, "persist", budgetMs, log);
+    log("persist:end");
+    bus.emit(BusChannels.ShutdownPersisted, {});
+    this.phase = "exiting";
+    bus.emit(BusChannels.SessionEnd, { exitCode: this.exitCode });
+    log("process.exit");
+    process.exit(this.exitCode);
+  }
+  async runHooks(hooks, phase, budgetMs, log) {
+    for (let i = 0; i < hooks.length; i++) {
+      const hook = hooks[i];
+      if (!hook) continue;
+      const t0 = process.hrtime.bigint();
+      const completed = await runWithBudget(hook, budgetMs, (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        writeShutdownNotice(`[clio:termination] ${phase}[${i}] failed: ${message}`);
+        if (err instanceof Error && err.stack) log(err.stack);
+      });
+      const dt = Number(process.hrtime.bigint() - t0) / 1e6;
+      if (!completed) {
+        writeShutdownNotice(`[clio:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; shutdown continues`);
+      }
+      log(`  ${phase}[${i}] ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}`);
+    }
+  }
+  /**
+   * SIGHUP is here for the same reason as SIGTERM. Without a listener Node
+   * takes its default action and the process dies with no shutdown at all,
+   * which on a TUI session means the terminal is never given back. Exit codes
+   * follow the 128+signal convention.
+   */
+  installSignalHandlers() {
+    if (this.signalHandler) return;
+    const handler = (signal) => {
+      this.notice(`Clio Coder: received ${signal}, shutting down...`);
+      void this.shutdown(SIGNAL_EXIT_CODES[signal] ?? 143);
+    };
+    this.signalHandler = handler;
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+    process.once("SIGHUP", handler);
+  }
+  /**
+   * Report something the operator should read after the process is gone,
+   * such as which signal ended it. Nothing here knows whether a TUI is on
+   * screen, but it does know that the terminal teardown is a drain hook: so
+   * until drain has finished the notice is held, and the moment it has, the
+   * notice goes to the terminal the TUI just handed back. Written straight
+   * away once drain is over, which is the case for a re-armed SIGINT arriving
+   * mid-shutdown. A second SIGTERM or SIGHUP inside the drain window takes
+   * Node's default action and the held notice dies with the process; that
+   * window is bounded by the per-hook budget and the shell reports the kill.
+   */
+  notice(text) {
+    if (this.drained) {
+      writeShutdownNotice(text);
+      return;
+    }
+    this.pendingNotices.push(text);
+  }
+  flushNotices() {
+    for (const text of this.pendingNotices.splice(0)) writeShutdownNotice(text);
+  }
+  /**
+   * Hand SIGINT to a foreground owner and return the call that takes it back.
+   *
+   * Boot arms this coordinator before any interactive surface exists, and Node
+   * runs signal listeners in registration order, so a TUI that merely added its
+   * own listener would lose every first press to a shutdown already underway.
+   * One owner holds the interrupt at a time and the transfer is explicit.
+   * SIGTERM is not part of the handover; it is never an interactive gesture.
+   */
+  releaseInterruptOwnership() {
+    const handler = this.signalHandler;
+    if (!handler) return () => {
+    };
+    process.off("SIGINT", handler);
+    let restored = false;
+    return () => {
+      if (restored) return;
+      restored = true;
+      process.once("SIGINT", handler);
+    };
+  }
+};
+var coordinator = null;
+function getTerminationCoordinator() {
+  if (!coordinator) coordinator = new TerminationCoordinator();
+  return coordinator;
+}
+
+export {
+  writeShutdownNotice,
+  resolveShutdownHookBudgetMs,
+  runWithBudget,
+  getTerminationCoordinator
+};
+//# sourceMappingURL=chunk-TZTZS7QK.js.map

package/dist/chunk-UOV2BYIW.js

@@ -0,0 +1,107 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/loop-detector.ts
+init_esm_shims();
+var DEFAULT_WINDOW_MS = 3e4;
+var DEFAULT_MAX_REPEATS = 3;
+var DEFAULT_KEEP_LAST_ATTEMPTS = 4;
+function createLoopState(opts) {
+  const windowMs = opts?.windowMs ?? DEFAULT_WINDOW_MS;
+  const maxRepeats = opts?.maxRepeats ?? DEFAULT_MAX_REPEATS;
+  const keepLastAttempts = opts?.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  return { recent: [], windowMs, maxRepeats, keepLastAttempts };
+}
+function hashToolCall(tool, args) {
+  let argPart;
+  try {
+    argPart = canonicalSerialize(args ?? {}, /* @__PURE__ */ new WeakSet());
+  } catch {
+    argPart = "<unrepresentable>";
+  }
+  return `${tool}${argPart}`;
+}
+function canonicalSerialize(value, seen) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`canonicalSerialize: non-finite number ${String(value)} is not representable`);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    throw new Error("canonicalSerialize: bigint is not representable");
+  }
+  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
+    throw new Error(`canonicalSerialize: ${typeof value} is not representable`);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    try {
+      const parts = [];
+      for (let i = 0; i < value.length; i++) {
+        if (!(i in value) || value[i] === void 0) {
+          parts.push("null");
+          continue;
+        }
+        parts.push(canonicalSerialize(value[i], seen));
+      }
+      return `[${parts.join(",")}]`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (typeof value === "object") {
+    if (value instanceof Date) {
+      const jsonValue = value.toJSON();
+      return jsonValue === null ? "null" : JSON.stringify(jsonValue);
+    }
+    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
+    seen.add(value);
+    const obj = value;
+    try {
+      const keys = Object.keys(obj).sort();
+      const parts = [];
+      for (const key of keys) {
+        const child = obj[key];
+        if (child === void 0) continue;
+        parts.push(`${JSON.stringify(key)}:${canonicalSerialize(child, seen)}`);
+      }
+      return `{${parts.join(",")}}`;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  throw new Error(`canonicalSerialize: unsupported value of type ${typeof value}`);
+}
+function observe(state, key, now) {
+  const cutoff = now - state.windowMs;
+  const keepLast = state.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
+  const appended = [...state.recent, { key, at: now }];
+  const floorStart = Math.max(0, appended.length - keepLast);
+  const next = appended.filter((entry, index) => index >= floorStart || entry.at >= cutoff);
+  let count = 0;
+  for (const entry of next) {
+    if (entry.key === key) count += 1;
+  }
+  const looping = count >= state.maxRepeats;
+  const newState = {
+    recent: next,
+    windowMs: state.windowMs,
+    maxRepeats: state.maxRepeats
+  };
+  return [newState, { looping, key, count }];
+}
+
+export {
+  createLoopState,
+  hashToolCall,
+  observe
+};
+//# sourceMappingURL=chunk-UOV2BYIW.js.map