@ghostpaw/questlog 0.7.0 → 0.9.0

package/dist/cli_main-ED5BJPSR.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+import { validateInput, isErrorResult, questlogVersion, resolveQuestlogDbPath } from './chunk-RUSE7ZFF.js';
+import { reviewQuestlogTool, getQuestDetail, questlogSurfaceTools } from './chunk-3Y5F3SMB.js';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+var CliUsageError = class extends Error {
+  exitCode = 2;
+};
+var keyOf = (name) => name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+function parseCliArgs(argv, spec) {
+  const values = {};
+  const positions = [];
+  const flags = spec.flags ?? [];
+  const convert = (raw, arg) => {
+    let value = raw;
+    if (raw.startsWith("@")) {
+      try {
+        value = readFileSync(raw.slice(1), "utf8");
+      } catch {
+        throw new CliUsageError(`Cannot read value file: ${raw.slice(1)}`);
+      }
+    }
+    let result = value;
+    if (arg.type === "number" || arg.type === "integer") {
+      result = Number(value);
+      if (!value.trim() || !Number.isFinite(result) || arg.type === "integer" && !Number.isInteger(result))
+        throw new CliUsageError(`Expected ${arg.type} for ${arg.name}: ${value}`);
+    } else if (arg.type === "boolean") {
+      if (!["true", "false"].includes(value))
+        throw new CliUsageError(`Expected boolean for ${arg.name}`);
+      result = value === "true";
+    } else if (arg.type === "json") {
+      try {
+        result = JSON.parse(value);
+      } catch {
+        throw new CliUsageError(`Invalid JSON for ${arg.name}`);
+      }
+    }
+    if (arg.enum && !arg.enum.includes(result))
+      throw new CliUsageError(`${arg.name} must be one of: ${arg.enum.join(", ")}`);
+    return result;
+  };
+  let ended = false;
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!ended && token === "--") {
+      ended = true;
+      continue;
+    }
+    if (ended || token === "-" || !token.startsWith("-")) {
+      positions.push(token);
+      continue;
+    }
+    const [flag, inline] = token.split(/=(.*)/s);
+    const negative = flag?.startsWith("--no-");
+    const name = flag?.replace(/^--?/, "").replace(/^no-/, "");
+    const arg = flags.find(
+      (entry) => entry.name === name || keyOf(entry.name) === name || entry.short === name
+    );
+    if (!arg) {
+      const prefix = (name ?? "").slice(0, 3);
+      const suggestion = prefix ? flags.find((entry) => entry.name.startsWith(prefix)) : void 0;
+      throw new CliUsageError(
+        `Unknown flag: ${flag}${suggestion ? `; did you mean --${suggestion.name}?` : ""}`
+      );
+    }
+    if (negative && arg.type !== "boolean")
+      throw new CliUsageError(`--no-${arg.name} requires a boolean flag`);
+    let raw = inline;
+    if (arg.type === "boolean" && raw === void 0) raw = negative ? "false" : "true";
+    if (raw === void 0) {
+      const next = argv[i + 1];
+      if (next === void 0 || next.startsWith("--"))
+        throw new CliUsageError(`Missing value: --${arg.name}`);
+      raw = next;
+      i++;
+    }
+    const key = keyOf(arg.name);
+    if (arg.type === "array") {
+      const item = convert(raw, { ...arg, type: arg.itemType ?? "string" });
+      values[key] = [...values[key] ?? [], item];
+    } else values[key] = convert(raw, arg);
+  }
+  let index = 0;
+  for (const arg of spec.positionals ?? []) {
+    if (index >= positions.length) continue;
+    values[keyOf(arg.name)] = arg.variadic ? positions.slice(index).map((value) => convert(value, { ...arg, type: arg.itemType ?? arg.type })) : convert(positions[index], arg);
+    index = arg.variadic ? positions.length : index + 1;
+  }
+  if (index < positions.length)
+    throw new CliUsageError(`Unexpected positional: ${positions[index]}`);
+  for (const arg of [...flags, ...spec.positionals ?? []]) {
+    if (arg.required && values[keyOf(arg.name)] === void 0)
+      throw new CliUsageError(`Missing required argument: ${arg.name}`);
+  }
+  return values;
+}
+function renderCliHelp(spec) {
+  const describe = (arg) => `${arg.type}${arg.enum ? ` (${arg.enum.join("|")})` : ""}${arg.required ? " required" : ""}  ${arg.description ?? ""}`;
+  return `Usage: ${spec.command} ${(spec.positionals ?? []).map((arg) => `<${arg.name}${arg.variadic ? "..." : ""}>`).join(" ")} [flags]
+${spec.description ?? ""}
+
+Positionals:
+${(spec.positionals ?? []).map((arg) => `  ${arg.name}  ${describe(arg)}`).join("\n")}
+Flags:
+${(spec.flags ?? []).map((arg) => `  --${arg.name}${arg.short ? `, -${arg.short}` : ""}  ${describe(arg)}`).join("\n")}
+`;
+}
+
+// src/surface/plain_dates.ts
+function parsePlainDue(raw, now = Date.now()) {
+  const invalid = () => new CliUsageError(
+    `Invalid --due "${raw}". Use YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, +3d or an ISO date-time.`
+  );
+  if (/^-?\d+$/.test(raw)) {
+    const value = Number(raw);
+    if (Number.isSafeInteger(value) && Number.isFinite(new Date(value).getTime())) return value;
+    throw invalid();
+  }
+  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
+  const european = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(raw);
+  let date;
+  if (iso || european) {
+    const year = Number(iso?.[1] ?? european?.[3]);
+    const month = Number(iso?.[2] ?? european?.[2]);
+    const day = Number(iso?.[3] ?? european?.[1]);
+    date = /* @__PURE__ */ new Date(0);
+    date.setFullYear(year, month - 1, day);
+    date.setHours(23, 59, 59, 999);
+    if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day)
+      throw invalid();
+  } else if (raw === "today" || raw === "tomorrow" || /^\+\d+d$/.test(raw)) {
+    date = new Date(now);
+    date.setDate(
+      date.getDate() + (raw === "today" ? 0 : raw === "tomorrow" ? 1 : Number(raw.slice(1, -1)))
+    );
+    date.setHours(23, 59, 59, 999);
+  } else {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw))
+      throw invalid();
+    parsePlainDue(raw.slice(0, 10), now);
+    date = new Date(raw);
+  }
+  if (!Number.isFinite(date.getTime())) throw invalid();
+  return date.getTime();
+}
+function formatPlainDate(value, full = false, now = Date.now()) {
+  const date = new Date(value);
+  const month = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ][date.getMonth()];
+  const year = full || date.getFullYear() !== new Date(now).getFullYear() ? ` ${date.getFullYear()}` : "";
+  const endOfDay = date.getHours() === 23 && date.getMinutes() === 59 && date.getSeconds() === 59 && date.getMilliseconds() === 999;
+  const time = endOfDay ? "" : ` ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+  return `${date.getDate()} ${month}${year}${time}`;
+}
+
+// src/surface/render_questlog_plain_result.ts
+function renderQuestlogPlainResult(result, db, values) {
+  const r = result;
+  const line = (item) => {
+    const detail = item.kind === "quest" ? getQuestDetail(db, item.id) : item;
+    const tags = "tagNames" in detail ? detail.tagNames : [];
+    return [
+      item.id,
+      detail.state ?? detail.markerId ?? "-",
+      detail.title,
+      ...tags.map((tag) => `#${tag}`),
+      ..."effectiveDueAt" in detail && detail.effectiveDueAt != null ? [
+        `${detail.resolvedAt == null && detail.effectiveDueAt < Date.now() ? "!overdue " : ""}due ${formatPlainDate(detail.effectiveDueAt)}`
+      ] : [],
+      ..."outcome" in detail && detail.outcome != null ? [`-> ${detail.outcome}`] : []
+    ].filter((v) => v != null).join(" ").replace(/[\r\n]+/g, " ");
+  };
+  if (!r.ok)
+    return r.outcome === "needs_clarification" ? `${r.clarification.question}
+Missing: ${r.clarification.missing.map((name) => `--${name}`).join(", ")}
+` : `${r.summary}
+${r.error.message}
+`;
+  if (r.data.items) {
+    const items = values.limit === void 0 ? r.data.items : r.data.items.slice(0, Math.max(0, Number(values.limit)));
+    return `${items.length ? items.map(line).join("\n") : r.summary}
+`;
+  }
+  if (r.data.item) {
+    const detail = getQuestDetail(db, r.data.item.detail.id);
+    const fields = [
+      ["id", detail.id],
+      ["title", detail.title],
+      ["objective", detail.objective],
+      ["state", detail.state],
+      ["tags", detail.tagNames.map((tag) => `#${tag}`).join(" ")],
+      ["due", detail.effectiveDueAt == null ? "-" : formatPlainDate(detail.effectiveDueAt, true)],
+      ["created", formatPlainDate(detail.createdAt, true)]
+    ];
+    if (detail.startedAt != null) fields.push(["started", formatPlainDate(detail.startedAt, true)]);
+    if (detail.resolvedAt != null)
+      fields.push([
+        detail.success ? "finished" : "abandoned",
+        formatPlainDate(detail.resolvedAt, true)
+      ]);
+    if (detail.outcome != null) fields.push(["outcome", detail.outcome]);
+    if (detail.questlineId != null) fields.push(["questline", detail.questlineId]);
+    const width = Math.max(...fields.map(([label]) => label.length));
+    return `${fields.map(([label, value]) => `${label.padEnd(width)}: ${String(value).replace(/[\r\n]+/g, " ")}`).join("\n")}
+`;
+  }
+  return `${r.summary.replace(/[\r\n]+/g, " ")}${r.data.primary ? ` (id ${r.data.primary.id})` : ""}
+`;
+}
+
+// src/surface/questlog_plain_commands.ts
+function questlogPlainCommands() {
+  const json = {
+    name: "json",
+    type: "boolean",
+    description: "Print the full tool result as JSON."
+  };
+  const limit = {
+    name: "limit",
+    type: "integer",
+    description: "Maximum displayed items (list text) or search matches."
+  };
+  const id = { name: "id", type: "integer", required: true };
+  const views = reviewQuestlogTool.inputSchema.properties?.view?.enum ?? [];
+  const commands = [
+    {
+      spec: {
+        command: "add",
+        description: "Create a quest. Objective defaults to the title.",
+        flags: [
+          { name: "title", type: "string", required: true },
+          { name: "tag", type: "array" },
+          { name: "objective", type: "string" },
+          {
+            name: "due",
+            type: "string",
+            description: "Local date, today, tomorrow, +3d, ISO date-time or epoch milliseconds."
+          },
+          { name: "questline", type: "integer" }
+        ]
+      },
+      tool: "shape_work",
+      input: (v) => {
+        const quest = {
+          title: v.title,
+          objective: v.objective ?? v.title
+        };
+        if (v.tag !== void 0)
+          quest.tags = v.tag.flatMap(
+            (tag) => tag.split(",").map((part) => part.trim()).filter(Boolean)
+          );
+        if (v.questline !== void 0) quest.questlineId = v.questline;
+        if (v.due !== void 0) {
+          quest.dueAt = parsePlainDue(String(v.due));
+        }
+        return { action: "create_quest", quest };
+      },
+      render: renderQuestlogPlainResult
+    },
+    {
+      spec: {
+        command: "list",
+        description: "Review quests and other work. Limit caps text output; JSON contains the full tool result.",
+        flags: [{ name: "view", type: "string", enum: ["available", ...views] }, limit]
+      },
+      tool: "review_questlog",
+      input: (v) => ({ view: !v.view || v.view === "available" ? "quests.available" : v.view }),
+      render: renderQuestlogPlainResult
+    },
+    {
+      spec: {
+        command: "done",
+        description: "Finish a quest with its outcome.",
+        positionals: [id],
+        flags: [
+          {
+            name: "outcome",
+            type: "string",
+            description: "What the finished quest produced; asked for when omitted."
+          }
+        ]
+      },
+      tool: "run_quest",
+      input: (v) => ({
+        action: "finish",
+        questId: v.id,
+        ...v.outcome === void 0 ? {} : { outcome: v.outcome }
+      }),
+      render: renderQuestlogPlainResult
+    },
+    {
+      spec: {
+        command: "search",
+        description: "Search quests and rumors.",
+        positionals: [{ name: "query", type: "string", variadic: true, required: true }],
+        flags: [limit]
+      },
+      tool: "search_questlog",
+      input: (v) => ({
+        query: v.query.join(" "),
+        ...v.limit === void 0 ? {} : { limit: v.limit }
+      }),
+      render: renderQuestlogPlainResult
+    },
+    {
+      spec: { command: "show", description: "Inspect a quest by id.", positionals: [id] },
+      tool: "inspect_questlog_item",
+      input: (v) => ({ target: { kind: "quest", id: v.id }, detailLevel: "full" }),
+      render: renderQuestlogPlainResult
+    }
+  ];
+  return commands.map((command) => ({
+    ...command,
+    spec: { ...command.spec, flags: [...command.spec.flags ?? [], json] },
+    input: (values) => {
+      if (values.limit !== void 0 && Number(values.limit) < 1)
+        throw new Error("Limit must be at least 1");
+      return command.input(values);
+    }
+  }));
+}
+
+// src/surface/questlog_cli_options.ts
+function selectedDbPath(options) {
+  const selected = resolveQuestlogDbPath(options.db === void 0 ? {} : { flag: options.db });
+  return selected === ":memory:" ? selected : resolve(selected);
+}
+var questlogCliOptions = {
+  bin: "ghostpaw-questlog",
+  version: questlogVersion,
+  description: "Local task and calendar library",
+  tools: questlogSurfaceTools,
+  describeDb: (options) => `Database: ${selectedDbPath(options)}
+Use --db <path> or GHOSTPAW_QUESTLOG_DB to override the default ~/.ghostpaw/questlog.db.`,
+  openContext: async (options) => {
+    const { openQuestlogDb } = await import('./open_questlog_db-SH3DAU4C.js');
+    const path = selectedDbPath(options);
+    const created = path !== ":memory:" && !existsSync(path);
+    const db = await openQuestlogDb(path);
+    if (created) process.stderr.write(`created ${path}
+`);
+    return db;
+  },
+  closeContext: (db) => db.close(),
+  commands: {
+    plain: questlogPlainCommands(),
+    mcp: async (options) => {
+      const { serveQuestlogMcp } = await import('./serve_questlog_mcp-J4ZHNEOT.js');
+      await serveQuestlogMcp(options.db === void 0 ? {} : { dbPath: options.db });
+    },
+    skill: async () => {
+      const { renderSkillMarkdown } = await import('./skill_markdown-7HCMSJYR.js');
+      const { questlogSkillSpec } = await import('./questlog_skill_spec-JLZH3JL2.js');
+      return renderSkillMarkdown(questlogSkillSpec);
+    }
+  }
+};
+
+// src/surfaces/cli_output.ts
+function enrichPlainJson(value) {
+  if (Array.isArray(value)) return value.map(enrichPlainJson);
+  if (value === null || typeof value !== "object") return value;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = enrichPlainJson(entry);
+    if (key.endsWith("At") && typeof entry === "number" && Number.isFinite(new Date(entry).getTime()))
+      result[`${key}Iso`] = new Date(entry).toISOString();
+  }
+  return result;
+}
+function suggestCommand(input, names) {
+  let best;
+  let distance = 3;
+  for (const name of names) {
+    let row = Array.from({ length: name.length + 1 }, (_, i) => i);
+    for (let i = 0; i < input.length; i++) {
+      const next = [i + 1];
+      for (let j = 0; j < name.length; j++)
+        next.push(
+          Math.min(
+            (next[j] ?? 0) + 1,
+            (row[j + 1] ?? 0) + 1,
+            (row[j] ?? 0) + (input[i] === name[j] ? 0 : 1)
+          )
+        );
+      row = next;
+    }
+    const current = row[name.length] ?? 3;
+    if (current < distance) {
+      best = name;
+      distance = current;
+    }
+  }
+  return best;
+}
+
+// src/surfaces/cli.ts
+async function runToolCli(argv, options) {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const stdin = options.stdin ?? process.stdin;
+  const args = [...argv];
+  let db;
+  let compact = false;
+  const fail = (message, code = 2) => {
+    stderr.write(`${message}
+`);
+    return code;
+  };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--db") {
+      if (!args[i + 1] || args[i + 1]?.startsWith("--")) return fail("--db requires a path");
+      db = args[i + 1];
+      args.splice(i, 2);
+      i--;
+    } else if (args[i] === "--compact") {
+      compact = true;
+      args.splice(i, 1);
+      i--;
+    }
+  }
+  const ctxOptions = db === void 0 ? {} : { db };
+  const command = args.shift() ?? "help";
+  const normalize = (name2) => name2.replace(/[-_]/g, "").toLowerCase();
+  if (["help", "--help", "-h"].includes(command)) {
+    stdout.write(
+      `${options.bin} ${options.version}
+${options.description}
+
+Usage: ${options.bin} [--db path] <command>
+Commands: ${options.commands?.plain?.map((entry) => entry.spec.command).join(", ") ?? ""}${options.commands?.plain?.length ? ", " : ""}tools [--json], describe <tool>, call <tool> [JSON|-], <tool> --parameter value, mcp, skill
+Options: --help, --version, --compact, --db <path>
+${options.describeDb ? `${options.describeDb(ctxOptions)}
+` : ""}
+${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")}
+`
+    );
+    return 0;
+  }
+  if (["--version", "-v"].includes(command)) {
+    stdout.write(`${options.version}
+`);
+    return 0;
+  }
+  if (command === "tools") {
+    stdout.write(
+      args.includes("--json") ? `${JSON.stringify(
+        options.tools.map(({ handler: _handler, ...tool2 }) => tool2),
+        null,
+        2
+      )}
+` : `${options.tools.map((tool2) => `${tool2.name}	${tool2.description.replace(/\s+/g, " ")}`).join("\n")}
+`
+    );
+    return 0;
+  }
+  if (command === "skill") {
+    if (!options.commands?.skill) return fail("skill command unavailable");
+    stdout.write(await options.commands.skill());
+    return 0;
+  }
+  if (command === "mcp") {
+    if (!options.commands?.mcp) return fail("mcp command unavailable");
+    await options.commands.mcp(ctxOptions);
+    return 0;
+  }
+  const plain = options.commands?.plain?.find((entry) => entry.spec.command === command);
+  let plainValues = {};
+  if (plain) {
+    if (args.includes("--help") || args.includes("-h")) {
+      stdout.write(
+        renderCliHelp({
+          ...plain.spec,
+          command: `${options.bin} ${command}`,
+          flags: [
+            ...plain.spec.flags ?? [],
+            { name: "db", type: "string" },
+            { name: "compact", type: "boolean" }
+          ]
+        })
+      );
+      return 0;
+    }
+    try {
+      plainValues = parseCliArgs(args, plain.spec);
+    } catch (cause) {
+      return fail(String(cause), cause instanceof CliUsageError ? 2 : 1);
+    }
+  }
+  const name = plain ? plain.tool : command === "call" || command === "describe" ? args.shift() : command;
+  const tool = options.tools.find((tool2) => normalize(tool2.name) === normalize(name ?? ""));
+  if (!tool) {
+    if (command === "call" || command === "describe") return fail(`Unknown tool: ${name ?? ""}`);
+    const suggestion = suggestCommand(command, [
+      ...options.commands?.plain?.map((entry) => entry.spec.command) ?? [],
+      "help",
+      "tools",
+      "describe",
+      "call",
+      "mcp",
+      "skill",
+      ...options.tools.map((entry) => entry.name)
+    ]);
+    return fail(`Unknown command: ${command}.${suggestion ? ` Did you mean ${suggestion}?` : ""}`);
+  }
+  if (command === "describe") {
+    stdout.write(
+      `${tool.name}
+${tool.description}
+Use when: ${tool.whenToUse ?? ""}
+Not for: ${tool.whenNotToUse ?? ""}
+Read only: ${tool.readOnly ?? false}
+
+Parameter | Type | Required | Description
+${Object.entries(
+        tool.inputSchema.properties ?? {}
+      ).map(
+        ([key, schema]) => `${key} | ${schema.type ?? "oneOf"} | ${tool.inputSchema.required?.includes(key) ?? false} | ${schema.description ?? ""}`
+      ).join("\n")}
+
+${JSON.stringify(tool.inputSchema, null, 2)}
+`
+    );
+    return 0;
+  }
+  let input = {};
+  try {
+    const readStdin = async () => {
+      let text = "";
+      for await (const chunk of stdin) text += String(chunk);
+      return text;
+    };
+    if (plain) {
+      input = plain.input(plainValues);
+    } else if (command === "call") {
+      if (args.length > 1) return fail("Expected a single JSON argument");
+      const raw = args[0];
+      input = JSON.parse(
+        raw === "-" || raw === void 0 && !stdin.isTTY ? await readStdin() : raw ?? "{}"
+      );
+    } else {
+      const values = {};
+      const coerce = (value, schema) => {
+        if (schema.type === "number" || schema.type === "integer") return Number(value);
+        if (schema.type === "boolean") {
+          if (!["true", "false"].includes(value)) throw new Error("Expected true or false");
+          return value === "true";
+        }
+        if (schema.type === "object" || schema.type === "array") return JSON.parse(value);
+        if (schema.oneOf) {
+          for (const branch of schema.oneOf) {
+            try {
+              const converted = coerce(value, branch);
+              if (!validateInput(branch, converted).length) return converted;
+            } catch {
+            }
+          }
+        }
+        return value;
+      };
+      while (args.length) {
+        const flag = args.shift();
+        if (!flag?.startsWith("--")) return fail(`Expected parameter flag: ${flag}`);
+        const equal = flag.indexOf("=");
+        const key = equal === -1 ? flag.slice(2) : flag.slice(2, equal);
+        const property = Object.keys(tool.inputSchema.properties ?? {}).find(
+          (name2) => normalize(name2) === normalize(key)
+        );
+        if (!property) return fail(`Unknown parameter: ${key}`);
+        const schema = tool.inputSchema.properties?.[property];
+        const raw = equal === -1 ? schema.type === "boolean" && (!args[0] || args[0].startsWith("--")) ? "true" : args.shift() : flag.slice(equal + 1);
+        if (raw === void 0) return fail(`Missing value: ${key}`);
+        if (schema.type === "array" && !raw.startsWith("[")) {
+          const prior = values[property];
+          values[property] = [
+            ...Array.isArray(prior) ? prior : [],
+            coerce(raw, schema.items ?? {})
+          ];
+        } else values[property] = coerce(raw, schema);
+      }
+      input = values;
+    }
+  } catch (cause) {
+    if (cause instanceof CliUsageError) return fail(cause.message, 2);
+    return fail(`Invalid input: ${cause instanceof Error ? cause.message : String(cause)}`, 1);
+  }
+  const errors = validateInput(tool.inputSchema, input);
+  if (errors.length) return fail(errors.join("\n"), 1);
+  let context;
+  try {
+    context = await options.openContext(ctxOptions);
+  } catch (cause) {
+    return fail(String(cause), 1);
+  }
+  try {
+    const result = await tool.handler(context, input);
+    stdout.write(
+      plain && !plainValues.json ? plain.render(result, context, plainValues) : `${JSON.stringify(plain ? enrichPlainJson(result) : result, null, compact ? void 0 : 2)}
+`
+    );
+    if (typeof result === "object" && result !== null && "outcome" in result && result.outcome === "needs_clarification")
+      return 3;
+    return isErrorResult(result) ? 1 : 0;
+  } catch (cause) {
+    return fail(String(cause), 1);
+  } finally {
+    await options.closeContext?.(context);
+  }
+}
+
+// src/cli_main.ts
+process.exitCode = await runToolCli(process.argv.slice(2), questlogCliOptions);