@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-CBAQPTDU.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  sumRunUsage
+} from "./chunk-ZR5YA6ZF.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/steer-channel.ts
+init_esm_shims();
+import * as fs from "node:fs";
+import { Socket } from "node:net";
+import * as readline from "node:readline";
+function setupSteerChannel(filePath, onLine) {
+  let closed = false;
+  let watcher = null;
+  let stream = null;
+  let rl = null;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    watcher?.close();
+    rl?.close();
+    stream?.destroy();
+  };
+  const reportError = (err) => {
+    if (closed) return;
+    process.stderr.write(
+      `clio-coder run: failed to setup steer channel: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    cleanup();
+  };
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.isFIFO()) {
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+      try {
+        stream = new Socket({ fd, readable: true, writable: false });
+      } catch (err) {
+        fs.closeSync(fd);
+        throw err;
+      }
+      stream.on("error", reportError);
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      rl.on("error", reportError);
+      rl.on("line", (line) => {
+        if (closed) return;
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+          onLine(trimmed);
+        }
+      });
+    } else {
+      let bytesRead = 0;
+      let leftover = "";
+      const readNewContent = () => {
+        if (closed) return;
+        try {
+          const currentStats = fs.statSync(filePath);
+          if (currentStats.size > bytesRead) {
+            let fd;
+            const buffer = Buffer.alloc(currentStats.size - bytesRead);
+            try {
+              fd = fs.openSync(filePath, "r");
+              fs.readSync(fd, buffer, 0, buffer.length, bytesRead);
+            } finally {
+              if (fd !== void 0) fs.closeSync(fd);
+            }
+            bytesRead = currentStats.size;
+            const text = `${leftover}${buffer.toString("utf-8")}`;
+            const lines = text.split(/\r?\n/);
+            leftover = lines.pop() ?? "";
+            for (const line of lines) {
+              if (closed) return;
+              const trimmed = line.trim();
+              if (trimmed.length > 0) {
+                onLine(trimmed);
+              }
+            }
+          }
+        } catch (_err) {
+        }
+      };
+      readNewContent();
+      watcher = fs.watch(filePath, (event) => {
+        if (event === "change") {
+          readNewContent();
+        }
+      });
+    }
+  } catch (err) {
+    reportError(err);
+  }
+  return cleanup;
+}
+
+// src/cli/modes/json-stream.ts
+init_esm_shims();
+function projectHeadlessJsonEvent(event) {
+  if (event.type === "message_update") return null;
+  if (event.type === "text_delta") {
+    return { type: event.type, contentIndex: event.contentIndex, delta: event.delta };
+  }
+  if (event.type === "thinking_delta") {
+    return { type: event.type, contentIndex: event.contentIndex, delta: event.delta };
+  }
+  if (event.type === "message_end") {
+    return { ...event, message: withoutStreamedContent(event.message) };
+  }
+  if (event.type === "agent_end") return segmentSummary(event.type, event.messages);
+  if (event.type === "turn_end") {
+    return { type: event.type, message: withoutStreamedContent(event.message) };
+  }
+  return event;
+}
+function withoutStreamedContent(message) {
+  if (!isRecord(message) || message.role !== "assistant" || !Array.isArray(message.content)) return message;
+  const content = message.content.map((block) => {
+    if (!isRecord(block)) return block;
+    if (block.type === "text" && typeof block.text === "string") {
+      const { text: _text, textSignature: _signature, ...rest } = block;
+      return { ...rest, streamed: true, textLength: block.text.length };
+    }
+    if (block.type === "thinking" && typeof block.thinking === "string") {
+      const { thinking: _thinking, thinkingSignature: _signature, ...rest } = block;
+      return { ...rest, streamed: true, thinkingLength: block.thinking.length };
+    }
+    return block;
+  });
+  return { ...message, content };
+}
+function projectDispatchJsonEvent(event) {
+  if (!isRecord(event) || event.type !== "agent_end" || !Array.isArray(event.messages)) return event;
+  const { messages: _messages, ...rest } = event;
+  return { ...rest, ...segmentSummary("agent_end", event.messages) };
+}
+function segmentSummary(type, messages) {
+  const usage = sumRunUsage(messages);
+  return {
+    type,
+    messageCount: messages.length,
+    usage: {
+      input: usage.input,
+      output: usage.output,
+      cacheRead: usage.cacheRead,
+      cacheWrite: usage.cacheWrite,
+      reasoning: usage.reasoning,
+      totalTokens: usage.tokens,
+      costUsd: usage.costUsd,
+      apiCalls: usage.apiCalls,
+      measured: usage.hadUsage
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  setupSteerChannel,
+  projectHeadlessJsonEvent,
+  projectDispatchJsonEvent
+};
+//# sourceMappingURL=chunk-CBAQPTDU.js.map

package/dist/chunk-CDQ2UC6W.js

@@ -0,0 +1,125 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  enabledPluginResourceRoots
+} from "./chunk-NVPXXW2H.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/resources/common-loader.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+var COMPAT_RESOURCE_PRECEDENCE = {
+  package: 10,
+  userCompat: 20,
+  user: 30,
+  projectCompat: 40,
+  project: 50
+};
+function defaultScopedResourceRoots(kind, cwd) {
+  return [
+    ...enabledPluginResourceRoots(kind, cwd).map((root) => ({
+      path: root.path,
+      rootPath: root.rootPath,
+      plugin: true,
+      scope: "package",
+      source: root.source,
+      precedence: COMPAT_RESOURCE_PRECEDENCE.package,
+      trusted: root.trust !== "foreign"
+    })),
+    {
+      path: path.join(clioConfigDir(), kind),
+      scope: "user",
+      source: "config",
+      precedence: COMPAT_RESOURCE_PRECEDENCE.user
+    },
+    {
+      path: path.join(cwd, ".clio-coder", kind),
+      scope: "project",
+      source: "project",
+      precedence: COMPAT_RESOURCE_PRECEDENCE.project
+    }
+  ];
+}
+function sourceInfoForRoot(root, filePath) {
+  return {
+    path: filePath,
+    scope: root.scope,
+    ...root.source ? { source: root.source } : {},
+    ...root.precedence !== void 0 ? { precedence: root.precedence } : {}
+  };
+}
+function readRootEntries(root, label, diagnostics) {
+  if (!existsSync(root.path)) return [];
+  let stat;
+  try {
+    stat = statSync(root.path);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({
+      type: "warning",
+      message: `${label} root could not be stat'ed: ${reason}`,
+      path: root.path
+    });
+    return [];
+  }
+  if (!stat.isDirectory()) {
+    diagnostics.push({ type: "warning", message: `${label} root is not a directory`, path: root.path });
+    return [];
+  }
+  try {
+    return readdirSync(root.path, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({ type: "warning", message: `${label} root could not be read: ${reason}`, path: root.path });
+    return [];
+  }
+}
+function splitYamlFrontmatter(raw) {
+  const opening = raw.match(/^---\r?\n/);
+  if (!opening) return { ok: false, reason: "missing", body: raw };
+  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
+  closeRegex.lastIndex = opening[0].length;
+  const closing = closeRegex.exec(raw);
+  if (!closing) return { ok: false, reason: "missing closing delimiter", body: raw };
+  const body = raw.slice(closing.index + closing[0].length);
+  const frontmatterText = raw.slice(opening[0].length, closing.index);
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(frontmatterText);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `invalid YAML: ${reason}`, body };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, reason: "must be a YAML object", body };
+  }
+  return {
+    ok: true,
+    frontmatter: parsed,
+    body
+  };
+}
+function stringField(frontmatter, key) {
+  const value = frontmatter[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+export {
+  COMPAT_RESOURCE_PRECEDENCE,
+  defaultScopedResourceRoots,
+  sourceInfoForRoot,
+  readRootEntries,
+  splitYamlFrontmatter,
+  stringField
+};
+//# sourceMappingURL=chunk-CDQ2UC6W.js.map

package/dist/chunk-CN6SW5DC.js

@@ -0,0 +1,177 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  Id,
+  PageCursor
+} from "./chunk-NG3QQSXY.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// apps/clio-coder-gui/contracts/fleet.ts
+init_esm_shims();
+var closed = { additionalProperties: false };
+var text = typebox_exports.String();
+var nullable = typebox_exports.Union([text, typebox_exports.Null()]);
+var count = typebox_exports.Integer({ minimum: 0 });
+var FleetPageQuery = typebox_exports.Object(
+  { limit: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1, maximum: 100 })), cursor: typebox_exports.Optional(PageCursor) },
+  closed
+);
+var FleetRoot = typebox_exports.Object(
+  {
+    id: Id,
+    fleet: text,
+    planHash: text,
+    startedAt: text,
+    endedAt: nullable,
+    resumedFrom: nullable,
+    stepCount: count,
+    completedCount: count
+  },
+  closed
+);
+var FleetRoots = typebox_exports.Object(
+  { items: typebox_exports.Array(FleetRoot), nextCursor: typebox_exports.Union([PageCursor, typebox_exports.Null()]) },
+  closed
+);
+var DispatchRun = typebox_exports.Object(
+  {
+    id: Id,
+    agentId: text,
+    executionRole: text,
+    task: text,
+    targetId: text,
+    wireModelId: text,
+    runtimeId: text,
+    startedAt: text,
+    endedAt: nullable,
+    status: text,
+    outcome: nullable,
+    outcomeDetail: nullable,
+    cwd: text,
+    sessionId: nullable,
+    tokenCount: typebox_exports.Number(),
+    costUsd: typebox_exports.Number(),
+    parentRunId: nullable,
+    rootRunId: nullable
+  },
+  closed
+);
+var DispatchRuns = typebox_exports.Object(
+  { items: typebox_exports.Array(DispatchRun), nextCursor: typebox_exports.Union([PageCursor, typebox_exports.Null()]) },
+  closed
+);
+var FleetReceipt = typebox_exports.Object(
+  { receipt: typebox_exports.Union([typebox_exports.Record(text, typebox_exports.Unknown()), typebox_exports.Null()]) },
+  closed
+);
+var memberTurn = typebox_exports.Object(
+  { round: count, runId: text, status: text, outcome: nullable, terminal: typebox_exports.Boolean() },
+  closed
+);
+var member = typebox_exports.Object(
+  {
+    label: text,
+    agentId: text,
+    targetId: text,
+    wireModelId: text,
+    executionRole: text,
+    turns: typebox_exports.Array(memberTurn),
+    turnsTruncated: typebox_exports.Boolean()
+  },
+  closed
+);
+var judge = typebox_exports.Object(
+  { runId: text, agentId: text, targetId: text, wireModelId: text, status: text, outcome: nullable },
+  closed
+);
+var Council = typebox_exports.Object(
+  {
+    group: text,
+    startedAt: text,
+    endedAt: nullable,
+    running: typebox_exports.Boolean(),
+    roundsPlanned: typebox_exports.Union([count, typebox_exports.Null()]),
+    roundsObserved: count,
+    origin: nullable,
+    approval: nullable,
+    members: typebox_exports.Array(member),
+    membersTruncated: typebox_exports.Boolean(),
+    membersRejected: count,
+    synthesis: typebox_exports.Object({ kind: nullable, sealedRunId: nullable, judge: typebox_exports.Union([judge, typebox_exports.Null()]) }, closed)
+  },
+  closed
+);
+var Councils = typebox_exports.Object({ councils: typebox_exports.Array(Council), truncated: typebox_exports.Boolean() }, closed);
+var correlation = typebox_exports.Object(
+  {
+    agent: typebox_exports.Boolean(),
+    target: typebox_exports.Boolean(),
+    modelFamily: typebox_exports.Boolean(),
+    runtime: typebox_exports.Boolean(),
+    node: typebox_exports.Boolean(),
+    independent: typebox_exports.Boolean()
+  },
+  closed
+);
+var FleetGate = typebox_exports.Object(
+  {
+    id: text,
+    group: text,
+    topology: text,
+    cycle: count,
+    outcome: text,
+    decidedAt: text,
+    subjects: typebox_exports.Array(text),
+    subjectsTruncated: typebox_exports.Boolean(),
+    decider: nullable,
+    correlation: typebox_exports.Union([correlation, typebox_exports.Null()]),
+    winner: typebox_exports.Union([typebox_exports.Object({ index: count, runId: text }, closed), typebox_exports.Null()]),
+    confirms: nullable,
+    reason: nullable
+  },
+  closed
+);
+var FleetGates = typebox_exports.Object(
+  { present: typebox_exports.Boolean(), decisions: typebox_exports.Array(FleetGate), truncated: typebox_exports.Boolean(), unverifiable: count },
+  closed
+);
+var FleetRootDetail = typebox_exports.Object(
+  {
+    run: FleetRoot,
+    steps: typebox_exports.Array(
+      typebox_exports.Object(
+        {
+          stepId: text,
+          terminalRunId: nullable,
+          assignmentId: nullable,
+          succeeded: typebox_exports.Boolean(),
+          integrityValid: typebox_exports.Boolean(),
+          failureReason: nullable,
+          output: text
+        },
+        closed
+      )
+    ),
+    receipt: FleetReceipt.properties.receipt,
+    councils: Councils,
+    gates: FleetGates
+  },
+  closed
+);
+
+export {
+  FleetPageQuery,
+  FleetRoot,
+  FleetRoots,
+  DispatchRun,
+  DispatchRuns,
+  FleetReceipt,
+  Councils,
+  FleetGates,
+  FleetRootDetail
+};
+//# sourceMappingURL=chunk-CN6SW5DC.js.map

package/dist/chunk-CRHPCPZP.js

@@ -0,0 +1,132 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  truncateUtf8
+} from "./chunk-MYI32N4R.js";
+import {
+  StringEnum
+} from "./chunk-L7G7K4I2.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  combineSafeOutput,
+  runCommandVector
+} from "./chunk-M2IPMWCN.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/safe-exec.ts
+init_esm_shims();
+var TRUNCATION_MARKER = "\n[output truncated]\n";
+function timeoutArg(args, fallback = SAFE_EXEC_DEFAULT_TIMEOUT_MS) {
+  return typeof args.timeout_ms === "number" && args.timeout_ms > 0 ? Math.floor(args.timeout_ms) : fallback;
+}
+function cwdArg(args) {
+  return typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0;
+}
+function maxOutputArg(args) {
+  return typeof args.max_output_bytes === "number" && args.max_output_bytes > 0 ? Math.floor(args.max_output_bytes) : SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+}
+function resultDetails(result) {
+  return {
+    command: [result.file, ...result.args].join(" "),
+    argv: [result.file, ...result.args],
+    cwd: result.cwd,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    aborted: result.aborted,
+    timedOut: result.timedOut,
+    outputCapped: result.outputCapped
+  };
+}
+async function runVectorTool(action, file, vectorArgs, args, options) {
+  const timeoutMs = timeoutArg(args);
+  const maxOutputBytes = maxOutputArg(args);
+  try {
+    const runOptions = { timeoutMs, maxOutputBytes };
+    const cwd = cwdArg(args);
+    if (cwd !== void 0) runOptions.cwd = cwd;
+    if (options?.signal !== void 0) runOptions.signal = options.signal;
+    const result = await runCommandVector(file, vectorArgs, runOptions);
+    const output = truncateUtf8(combineSafeOutput(result), maxOutputBytes, TRUNCATION_MARKER);
+    const details = resultDetails(result);
+    if (result.aborted) return { kind: "error", message: `${action}: aborted`, details };
+    if (result.timedOut) {
+      const status = `${action}: timed out after ${timeoutMs}ms`;
+      return { kind: "error", message: output.trim().length > 0 ? `${status}
+
+${output.trim()}` : status, details };
+    }
+    if (result.outputCapped)
+      return {
+        kind: "error",
+        message: output.trim().length > 0 ? `${action}: output exceeded ${maxOutputBytes} bytes
+
+${output.trim()}` : `${action}: output exceeded ${maxOutputBytes} bytes`,
+        details
+      };
+    if (result.exitCode !== 0) {
+      return {
+        kind: "error",
+        message: `${action}: exited with code ${result.exitCode ?? "?"}: ${output.trim()}`,
+        details
+      };
+    }
+    return { kind: "ok", output, details };
+  } catch (err) {
+    return { kind: "error", message: `${action}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var gitTool = {
+  name: ToolNames.Git,
+  description: "Read-only git inspection: op=status (short status), diff, or log (oneline).",
+  parameters: typebox_exports.Object({
+    op: StringEnum(["status", "diff", "log"], { description: "Inspection to run." }),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "Limit diff/log to one path." })),
+    cached: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: staged changes (--cached)." })),
+    stat: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: summary only (--stat)." })),
+    name_only: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: file names only." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "log: commits to show (default 20, max 200)." })),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in ms (default 120000)." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  async run(args, options) {
+    const op = typeof args.op === "string" ? args.op : "";
+    const pathArg = typeof args.path === "string" && args.path.length > 0 ? args.path : null;
+    if (op === "status") {
+      return runVectorTool("git", "git", ["status", "--short", "--branch"], args, options);
+    }
+    if (op === "diff") {
+      const vector = ["diff"];
+      if (args.cached === true) vector.push("--cached");
+      if (args.stat === true) vector.push("--stat");
+      if (args.name_only === true) vector.push("--name-only");
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    if (op === "log") {
+      const limit = typeof args.limit === "number" && args.limit > 0 ? Math.min(200, Math.floor(args.limit)) : 20;
+      const vector = ["log", "--oneline", "-n", String(limit)];
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    return { kind: "error", message: `git: op must be status, diff, or log; got '${op}'` };
+  }
+};
+
+export {
+  timeoutArg,
+  maxOutputArg,
+  runVectorTool,
+  gitTool
+};
+//# sourceMappingURL=chunk-CRHPCPZP.js.map

package/dist/chunk-CTFPFW3H.js

@@ -0,0 +1,44 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  StringEnum
+} from "./chunk-L7G7K4I2.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/context/surface.ts
+init_esm_shims();
+var contextToolSurface = {
+  name: ToolNames.Context,
+  description: "Environment context: scope=settings explains current effective settings, autonomy, configured limits, and exact UI commands without exposing credentials; scope=workspace returns the git/project snapshot, scope=skills lists ready skills, installed package states and marketplace options, or loads a ready skill by name, scope=recall returns an exact persisted evicted or summarized tool result by ref; omit ref to discover historical results by query with bounded limit/offset pages. Clio's documentation and the recipe catalog are gateway capabilities (clio_docs, clio_library). For repository code and the repo's generated wiki use code_nav (mode=wiki).",
+  parameters: typebox_exports.Object({
+    scope: StringEnum(["workspace", "settings", "skills", "recall"], { description: "Context source." }),
+    query: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "scope=settings: settings path, section, or terms; scope=recall without ref: path, tool, or ref terms."
+      })
+    ),
+    name: typebox_exports.Optional(typebox_exports.String({ description: "scope=skills: skill name to load; omit to list." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "scope=settings or recall: bounded page size (max 12)." })),
+    ref: typebox_exports.Optional(typebox_exports.String({ description: "scope=recall: exact persisted result ref; omit for discovery." })),
+    offset: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "scope=settings or recall discovery: zero-based offset; follow nextOffset (default 0)."
+      })
+    ),
+    include_tree: typebox_exports.Optional(typebox_exports.Boolean({ description: "scope=skills: list files under the skill base_dir." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  contextToolSurface
+};
+//# sourceMappingURL=chunk-CTFPFW3H.js.map