@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/event-EGNPGE5A.js

@@ -0,0 +1,372 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/event.ts
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { cwd as processCwd } from "node:process";
+import { appendEvent } from "@cleocode/core/events/event-bus.js";
+var VALID_KINDS = [
+  "spawn",
+  "heartbeat",
+  "tool-start",
+  "tool-end",
+  "commit",
+  "blocked",
+  "complete"
+];
+var projectArgs = {
+  project: {
+    type: "string",
+    description: "Project root (defaults to process cwd)"
+  },
+  json: {
+    type: "boolean",
+    description: "Emit LAFS JSON envelope"
+  }
+};
+function resolveProjectRoot(arg) {
+  return arg && arg.length > 0 ? arg : processCwd();
+}
+var appendSub = defineCommand({
+  meta: {
+    name: "append",
+    description: "Emit a structured lifecycle event from an agent worker"
+  },
+  args: {
+    ...projectArgs,
+    kind: {
+      type: "string",
+      description: `Event kind: ${VALID_KINDS.join(" | ")}`,
+      required: true
+    },
+    task: {
+      type: "string",
+      description: "Task ID the worker is executing (e.g. T1234)",
+      required: true
+    },
+    agent: {
+      type: "string",
+      description: "Agent identity string (e.g. cleo-worker-T1234)",
+      required: true
+    },
+    payload: {
+      type: "string",
+      description: `Optional JSON payload string (e.g. '{"tool":"Bash"}')`
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolveProjectRoot(args.project);
+    const kind = args.kind;
+    const taskId = args.task;
+    const agentId = args.agent;
+    if (!VALID_KINDS.includes(kind)) {
+      cliError(
+        `Invalid event kind '${kind}'. Valid kinds: ${VALID_KINDS.join(", ")}`,
+        "E_EVENT_INVALID_KIND"
+      );
+      process.exit(1);
+    }
+    let payload;
+    if (args.payload) {
+      try {
+        payload = JSON.parse(args.payload);
+      } catch {
+        cliError("--payload must be valid JSON", "E_EVENT_INVALID_PAYLOAD");
+        process.exit(1);
+      }
+    }
+    try {
+      await appendEvent(kind, taskId, agentId, projectRoot, payload);
+      cliOutput(
+        { kind, taskId, agentId, appended: true },
+        {
+          command: "event append",
+          message: `Event appended: ${kind} for ${taskId} by ${agentId}`,
+          operation: "event.append"
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(message, "E_EVENT_APPEND");
+      process.exit(1);
+    }
+  }
+});
+var tailSub = defineCommand({
+  meta: {
+    name: "tail",
+    description: "Stream structured events from agent event logs"
+  },
+  args: {
+    ...projectArgs,
+    agent: {
+      type: "string",
+      description: "Agent ID to tail (omit to list all agents)"
+    },
+    all: {
+      type: "boolean",
+      description: "Tail all agent log files"
+    },
+    lines: {
+      type: "string",
+      description: "Number of tail lines to show (default: 20)"
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolveProjectRoot(args.project);
+    const jsonMode = args.json === true;
+    const agentIdFilter = args.agent;
+    const showAll = args.all === true;
+    const lines = parseInt(args.lines ?? "20", 10);
+    const eventsDir = join(projectRoot, ".cleo", "agent-events");
+    try {
+      let files = [];
+      try {
+        const entries = await readdir(eventsDir);
+        files = entries.filter((f) => f.endsWith(".jsonl"));
+      } catch {
+      }
+      if (files.length === 0) {
+        cliOutput(
+          {
+            agents: [],
+            message: "No event logs found. Events are written when workers call appendEvent."
+          },
+          { command: "event tail", message: "No agent event logs found.", operation: "event.tail" }
+        );
+        return;
+      }
+      if (!agentIdFilter && !showAll) {
+        const agentIds = files.map((f) => f.replace(".jsonl", ""));
+        cliOutput(
+          { agents: agentIds },
+          {
+            command: "event tail",
+            message: `${agentIds.length} agent log(s): ${agentIds.join(", ")}`,
+            operation: "event.tail"
+          }
+        );
+        return;
+      }
+      const filesToTail = agentIdFilter ? files.filter((f) => f === `${agentIdFilter}.jsonl`) : files;
+      if (filesToTail.length === 0) {
+        cliError(`No event log for agent '${agentIdFilter}'`, "E_EVENT_TAIL_NOT_FOUND");
+        process.exit(1);
+      }
+      for (const file of filesToTail) {
+        const agentId = file.replace(".jsonl", "");
+        const { readFileSync } = await import("node:fs");
+        const content = readFileSync(join(eventsDir, file), "utf-8");
+        const eventLines = content.trim().split("\n").filter(Boolean);
+        const tail = eventLines.slice(-lines);
+        if (jsonMode) {
+          const events = tail.map((l) => {
+            try {
+              return JSON.parse(l);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          cliOutput(
+            { agentId, events },
+            {
+              command: "event tail",
+              message: `${events.length} event(s) for ${agentId}`,
+              operation: "event.tail"
+            }
+          );
+        } else {
+          process.stdout.write(`
+=== ${agentId} (${tail.length} events) ===
+`);
+          for (const line of tail) {
+            try {
+              const evt = JSON.parse(line);
+              const ts = new Date(evt.timestamp).toLocaleTimeString();
+              const payloadStr = evt.payload ? ` ${JSON.stringify(evt.payload)}` : "";
+              process.stdout.write(`  [${ts}] ${evt.kind.padEnd(12)} ${evt.taskId}${payloadStr}
+`);
+            } catch {
+              process.stdout.write(`  ${line}
+`);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(message, "E_EVENT_TAIL");
+      process.exit(1);
+    }
+  }
+});
+var orchestratorTailSub = defineCommand({
+  meta: {
+    name: "tail",
+    description: "Stream worker lifecycle events for an epic (agent.events.*)"
+  },
+  args: {
+    ...projectArgs,
+    epic: {
+      type: "string",
+      description: "Epic task ID to filter agent events (e.g. T1135)"
+    },
+    follow: {
+      type: "boolean",
+      description: "Poll for new events until Ctrl-C (default: show last 50 and exit)"
+    },
+    lines: {
+      type: "string",
+      description: "Number of tail lines per agent (default: 50)"
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolveProjectRoot(args.project);
+    const jsonMode = args.json === true;
+    const epicFilter = args.epic;
+    const follow = args.follow === true;
+    const lines = parseInt(args.lines ?? "50", 10);
+    const eventsDir = join(projectRoot, ".cleo", "agent-events");
+    let files = [];
+    try {
+      const entries = await readdir(eventsDir);
+      files = entries.filter((f) => f.endsWith(".jsonl"));
+      if (epicFilter) {
+        files = files.filter((f) => f.includes(epicFilter));
+        if (files.length === 0) files = entries.filter((f) => f.endsWith(".jsonl"));
+      }
+    } catch {
+    }
+    if (files.length === 0) {
+      cliOutput(
+        { agents: [], epicFilter },
+        {
+          command: "orchestrator tail",
+          message: epicFilter ? `No event logs for epic ${epicFilter}. Workers emit events via appendEvent.` : "No agent event logs found.",
+          operation: "orchestrator.tail"
+        }
+      );
+      return;
+    }
+    const printAgentLog = async (file) => {
+      const agentId = file.replace(".jsonl", "");
+      try {
+        const { readFileSync } = await import("node:fs");
+        const content = readFileSync(join(eventsDir, file), "utf-8");
+        const eventLines = content.trim().split("\n").filter(Boolean);
+        const tail = eventLines.slice(-lines);
+        if (jsonMode) {
+          const events = tail.map((l) => {
+            try {
+              return JSON.parse(l);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          process.stdout.write(JSON.stringify({ agentId, events }) + "\n");
+        } else {
+          process.stdout.write(`
+=== ${agentId} ===
+`);
+          for (const line of tail) {
+            try {
+              const evt = JSON.parse(line);
+              const ts = new Date(evt.timestamp).toLocaleTimeString();
+              const payloadStr = evt.payload ? ` ${JSON.stringify(evt.payload)}` : "";
+              process.stdout.write(`  [${ts}] ${evt.kind.padEnd(12)} ${evt.taskId}${payloadStr}
+`);
+            } catch {
+              process.stdout.write(`  ${line}
+`);
+            }
+          }
+        }
+      } catch {
+      }
+    };
+    for (const file of files) {
+      await printAgentLog(file);
+    }
+    if (!follow) return;
+    process.stdout.write("\n[following \u2014 Ctrl-C to stop]\n");
+    const interval = setInterval(async () => {
+      for (const file of files) {
+        await printAgentLog(file);
+      }
+    }, 2e3);
+    process.on("SIGINT", () => {
+      clearInterval(interval);
+      process.stdout.write("\n[disconnected]\n");
+      process.exit(0);
+    });
+  }
+});
+var orchestratorCommand = defineCommand({
+  meta: {
+    name: "orchestrator",
+    description: "Orchestration observability: stream worker event logs"
+  },
+  args: projectArgs,
+  subCommands: {
+    tail: orchestratorTailSub
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    cliOutput(
+      { subCommands: ["tail"] },
+      {
+        command: "orchestrator",
+        message: "Usage: cleo orchestrator tail [--epic <id>] [--follow]",
+        operation: "orchestrator"
+      }
+    );
+  }
+});
+var eventCommand = defineCommand({
+  meta: {
+    name: "event",
+    description: "CLEO Observability event bus: append lifecycle events and tail agent logs"
+  },
+  args: projectArgs,
+  subCommands: {
+    append: appendSub,
+    tail: tailSub
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    cliOutput(
+      { subCommands: ["append", "tail"] },
+      { command: "event", message: "Usage: cleo event append|tail", operation: "event" }
+    );
+  }
+});
+export {
+  eventCommand,
+  orchestratorCommand
+};
+//# sourceMappingURL=event-EGNPGE5A.js.map

package/dist/cli/exists-H4SDCBPL.js

@@ -0,0 +1,65 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/exists.ts
+import { ExitCode } from "@cleocode/contracts";
+import { getTask, resolveProjectRoot } from "@cleocode/core/internal";
+var existsCommand = defineCommand({
+  meta: { name: "exists", description: "Check if a task ID exists (exit 0=exists, 4=not found)" },
+  args: {
+    "task-id": { type: "positional", description: "Task ID to look up", required: true },
+    verbose: { type: "boolean", description: "Show task title and status when found" }
+  },
+  async run({ args }) {
+    const taskId = args["task-id"];
+    const cwd = resolveProjectRoot();
+    let task;
+    try {
+      task = await getTask(taskId, cwd);
+    } catch (err) {
+      cliError(
+        `exists: ${err instanceof Error ? err.message : String(err)}`,
+        ExitCode.GENERAL_ERROR,
+        {
+          name: "E_INTERNAL"
+        }
+      );
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    if (!task) {
+      cliOutput({ exists: false, taskId }, { command: "exists", operation: "tasks.exists" });
+      process.exit(ExitCode.NOT_FOUND);
+    }
+    const data = { exists: true, taskId };
+    if (args.verbose) {
+      data["title"] = task.title;
+      data["status"] = task.status;
+    }
+    cliOutput(data, { command: "exists", operation: "tasks.exists" });
+  }
+});
+export {
+  existsCommand
+};
+//# sourceMappingURL=exists-H4SDCBPL.js.map