@ghostpaw/questlog 0.9.2 → 0.11.0

package/dist/cli.js

@@ -13,5 +13,5 @@ function checkNodeVersion(version, stderr) {
 if (!checkNodeVersion(process.versions.node, process.stderr)) {
   process.exitCode = 2;
 } else {
-  await import('./cli_main-XNZP4TY2.js');
+  await import('./cli_main-TEG3QTDP.js');
 }

package/dist/{cli_main-XNZP4TY2.js → cli_main-TEG3QTDP.js}

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
-import { isErrorResult, questlogVersion, resolveQuestlogDbPath } from './chunk-DKH623HU.js';
-import { questlogSkills } from './chunk-6KTQK3ZE.js';
-import { reviewQuestlogTool, validateInput, getQuestDetail, questlogSurfaceTools } from './chunk-UTUQPSGO.js';
+import { questlogSkills } from './chunk-I2AMIXGP.js';
+import { CliUsageError, renderCliHelp, parseCliArgs } from './chunk-GVD6A3RR.js';
+import { isErrorResult, resolveQuestlogDbPath } from './chunk-IL2QRKZL.js';
+import { reviewQuestlogTool, validateInput, getQuestDetail, questlogSurfaceTools } from './chunk-KOWIVBG6.js';
+import { questlogVersion } from './chunk-RBGQK5WP.js';
+import { listDeliveries } from './chunk-D6EGZCT7.js';
+import './chunk-NBCCA6AX.js';
+import { schemaRows } from './chunk-7KTRNXTU.js';
 import { minimalInput } from './chunk-QYSIJ2YN.js';
 import { isSea } from 'node:sea';
-import { readFileSync, existsSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 var npmEntry = false;
@@ -15,7 +20,8 @@ function cliVersion(version, {
   sea = isSea,
   npm = npmEntry,
   platform = process.platform,
-  arch = process.arch
+  arch = process.arch,
+  args = []
 } = {}) {
   let binary = false;
   try {
@@ -23,116 +29,17 @@ function cliVersion(version, {
   } catch {
   }
   const target = `${platform === "win32" ? "windows" : platform}-${arch}`;
+  const variant = binary ? "binary" : npm ? "npm" : "library";
+  if (args.includes("--json"))
+    return JSON.stringify({ name: "questlog", version, variant, target });
+  if (args.includes("--short")) return version;
   return `questlog ${version} (${binary ? `binary, ${target}` : npm ? "npm" : "library"})`;
 }
-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 || /^--[a-z]/i.test(next))
-        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.`
+    `Invalid --due "${raw}". Use YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, +Nd (for example +3d), integer epoch milliseconds, or YYYY-MM-DDTHH:mm[:ss[.fraction]][Z|\xB1HH:mm] (no zone means local time).`
   );
   if (/^-?\d+$/.test(raw)) {
     const value = Number(raw);
@@ -158,7 +65,7 @@ function parsePlainDue(raw, now = Date.now()) {
     );
     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))
+    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);
@@ -210,6 +117,9 @@ function renderQuestlogPlainResult(result, db, values) {
 Missing: ${r.clarification.missing.map((name) => `--${name}`).join(", ")}
 ` : `${r.summary}
 ${r.error.message}
+`;
+  if (r.data.deliveries && !r.data.item)
+    return `${r.data.deliveries.map((d) => `${d.id} target ${d.targetId} ${d.status} attempts ${d.attempts} HTTP ${d.httpStatus ?? "-"} next ${new Date(d.nextAttemptAt).toISOString()} events ${d.events.map((e) => e.id).join(", ")}`).join("\n") || "No deliveries"}
 `;
   if (r.data.items) {
     const items = values.limit === void 0 ? r.data.items : r.data.items.slice(0, Math.max(0, Number(values.limit)));
@@ -235,6 +145,11 @@ ${r.error.message}
       ]);
     if (detail.outcome != null) fields.push(["outcome", detail.outcome]);
     if (detail.questlineId != null) fields.push(["questline", detail.questlineId]);
+    for (const delivery of listDeliveries(db, { questId: detail.id }))
+      fields.push([
+        "delivery",
+        `${delivery.id} target ${delivery.targetId} ${delivery.status} attempts ${delivery.attempts}`
+      ]);
     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")}
 `;
@@ -258,6 +173,34 @@ function questlogPlainCommands() {
   const id = { name: "id", type: "integer", required: true };
   const views = reviewQuestlogTool.inputSchema.properties?.view?.enum ?? [];
   const commands = [
+    {
+      spec: {
+        command: "tick",
+        description: "Detect events and deliver outbound webhooks once.",
+        flags: [{ name: "dry-run", type: "boolean" }]
+      },
+      tool: "manage_hooks",
+      input: (v) => ({ action: "tick", dry_run: v.dryRun ?? false }),
+      render: (r, _db, values) => {
+        const result = r;
+        if (!result.ok || !result.data) return `${result.summary}
+`;
+        const d = result.data;
+        return `${d.events.length} events found; ${d.sent} deliveries sent, ${d.queued} queued, ${d.retrying} retrying, ${d.failed} failed.
+${values.dryRun ? `${JSON.stringify({ events: d.events, batches: d.batches }, null, 2)}
+` : ""}`;
+      }
+    },
+    {
+      spec: {
+        command: "review",
+        description: "Review an operational view.",
+        positionals: [{ name: "view", type: "string", required: true, enum: views }]
+      },
+      tool: "review_questlog",
+      input: (v) => ({ view: v.view }),
+      render: renderQuestlogPlainResult
+    },
     {
       spec: {
         command: "add",
@@ -282,7 +225,10 @@ function questlogPlainCommands() {
             "give the title once: either as the first argument or with --title"
           );
         const title = v.positionalTitle ?? v.title;
-        if (title === void 0) throw new CliUsageError("Missing required argument: title");
+        if (title === void 0)
+          throw new CliUsageError(
+            'Missing required argument: title. Example: questlog add "Write the report" --due tomorrow'
+          );
         const quest = {
           title,
           objective: v.objective ?? title
@@ -370,13 +316,13 @@ function selectedDbPath(options) {
 var questlogCliOptions = {
   bin: "ghostpaw-questlog",
   version: questlogVersion,
-  versionLine: () => cliVersion(questlogVersion),
+  versionLine: (args) => cliVersion(questlogVersion, { args }),
   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 { openQuestlogDb } = await import('./open_questlog_db-6NS6BVBC.js');
     const path = selectedDbPath(options);
     const created = path !== ":memory:" && !existsSync(path);
     const db = await openQuestlogDb(path);
@@ -386,15 +332,58 @@ Use --db <path> or GHOSTPAW_QUESTLOG_DB to override the default ~/.ghostpaw/ques
   },
   closeContext: (db) => db.close(),
   commands: {
+    names: ["hook", "watch"],
+    run: async (command, args, options, io) => {
+      if (command === "show" && args[0]?.startsWith("d_")) {
+        const { listDeliveries: listDeliveries2 } = await import('./list_deliveries-WJEJUZIQ.js');
+        const { listHooks } = await import('./list_hooks-C5CAA2C7.js');
+        const { textOutput } = await import('./text_output-X7F3K23Q.js');
+        if (args.includes("--help") || args.includes("-h")) {
+          io.stdout.write("questlog show <delivery-id> [--json]\n");
+          return 0;
+        }
+        const { openQuestlogDb } = await import('./open_questlog_db-6NS6BVBC.js');
+        const db = await openQuestlogDb(selectedDbPath(options));
+        try {
+          const delivery = listDeliveries2(db, { includeDelivered: true }).find(
+            (d) => d.id === args[0]
+          );
+          if (!delivery) {
+            io.stderr.write(`Delivery ${args[0]} not found
+`);
+            return 1;
+          }
+          const target = listHooks(db).find((h) => h.id === delivery.targetId);
+          const result = {
+            ...delivery,
+            target: target ?? null,
+            eventIds: delivery.events.map((e) => e.id)
+          };
+          io.stdout.write(
+            `${args.includes("--json") ? JSON.stringify(result, null, 2) : textOutput(result)}
+`
+          );
+          return 0;
+        } finally {
+          db.close();
+        }
+      }
+      if (command !== "hook" && command !== "watch") return void 0;
+      const { runHookCommand } = await import('./run_hook_command-BOENYNDT.js');
+      return runHookCommand(command, args, io, async () => {
+        const { openQuestlogDb } = await import('./open_questlog_db-6NS6BVBC.js');
+        return openQuestlogDb(selectedDbPath(options));
+      });
+    },
     plain: questlogPlainCommands(),
     guides: questlogSkills,
     mcp: async (options) => {
-      const { serveQuestlogMcp } = await import('./serve_questlog_mcp-KFUYJB2P.js');
+      const { serveQuestlogMcp } = await import('./serve_questlog_mcp-X524X34F.js');
       await serveQuestlogMcp(options.db === void 0 ? {} : { dbPath: options.db });
     },
     skill: async () => {
-      const { renderSkillMarkdown } = await import('./skill_markdown-HXYQ3K6U.js');
-      const { questlogSkillSpec } = await import('./questlog_skill_spec-EM6DGGVN.js');
+      const { renderSkillMarkdown } = await import('./skill_markdown-EGKYZ3W2.js');
+      const { questlogSkillSpec } = await import('./questlog_skill_spec-ILTCTRYS.js');
       return renderSkillMarkdown(questlogSkillSpec);
     }
   }
@@ -463,6 +452,12 @@ async function runToolCli(argv, options) {
       i--;
     }
   }
+  const versionArgs = args.filter((arg) => arg !== "--short" && arg !== "--json");
+  if (versionArgs[0] === "--version" || versionArgs[0] === "-v") {
+    stdout.write(`${options.versionLine?.(args) ?? options.version}
+`);
+    return 0;
+  }
   const ctxOptions = db === void 0 ? {} : { db };
   const command = args.shift() ?? "help";
   const normalize = (name2) => name2.replace(/[-_]/g, "").toLowerCase();
@@ -472,8 +467,14 @@ async function runToolCli(argv, options) {
 ${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
+Commands: ${[
+        ...options.commands?.plain?.map((entry) => entry.spec.command) ?? [],
+        ...options.commands?.names ?? []
+      ].map((name2) => `${name2}, `).join(
+        ""
+      )}tools [--json], describe <tool>, call <tool> [JSON|-], <tool> --parameter value, mcp, skill
 Options: --help, --version, --compact, --db <path>
+Version formats: --version --short, --version --json
 ${options.describeDb ? `${options.describeDb(ctxOptions)}
 ` : ""}
 ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")}
@@ -481,9 +482,11 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
     );
     return 0;
   }
-  if (["--version", "-v"].includes(command)) {
-    stdout.write(`${options.versionLine?.() ?? options.version}
-`);
+  if (["tools", "call", "describe"].includes(command) && args.length === 1 && ["--help", "-h"].includes(args[0] ?? "")) {
+    stdout.write(
+      `Usage: ${options.bin} ${command}${command === "tools" ? " [--json]" : " <tool> [--help]"}
+`
+    );
     return 0;
   }
   if (command === "tools") {
@@ -500,16 +503,21 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
   }
   if (command === "skill") {
     if (!options.commands?.skill) return fail("skill command unavailable");
-    if (args.length > 1) return fail(`Usage: ${options.bin} skill [--list | <guide> | --help]`);
-    const guide = args[0];
+    if (args.length > 1 && !args.some((arg) => ["--help", "-h"].includes(arg)))
+      return fail(`Usage: ${options.bin} skill [--short | --list | <guide> | --help]`);
+    const guide = args.some((arg) => ["--help", "-h"].includes(arg)) ? "--help" : args[0];
     if (guide === "--help" || guide === "-h") {
       stdout.write(
         `Usage:
   ${options.bin} skill
   ${options.bin} skill --list
+  ${options.bin} skill --short
   ${options.bin} skill <guide>
 `
       );
+    } else if (guide === "--short") {
+      const full = await options.commands.skill();
+      stdout.write(full.split("## Appendix:")[0]?.replace(/^---[\s\S]*?---\n+/, "") ?? full);
     } else if (guide === "--list") {
       stdout.write(
         `${(options.commands.guides ?? []).map((entry) => `${entry.name}  ${entry.description.replace(/\s+/g, " ")}`).join("\n")}
@@ -522,11 +530,22 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
     } else stdout.write(await options.commands.skill());
     return 0;
   }
+  if (command === "mcp" && (args.includes("--help") || args.includes("-h"))) {
+    stdout.write(`${options.bin} mcp [--db path]
+`);
+    return 0;
+  }
   if (command === "mcp") {
     if (!options.commands?.mcp) return fail("mcp command unavailable");
     await options.commands.mcp(ctxOptions);
     return 0;
   }
+  const custom = await options.commands?.run?.(command, args, ctxOptions, {
+    stdin,
+    stdout,
+    stderr
+  });
+  if (custom !== void 0) return custom;
   const plain = options.commands?.plain?.find((entry) => entry.spec.command === command);
   let plainValues = {};
   if (plain) {
@@ -556,6 +575,7 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
     if (command === "call" || command === "describe") return fail(`Unknown tool: ${name ?? ""}`);
     const suggestion = suggestCommand(command, [
       ...options.commands?.plain?.map((entry) => entry.spec.command) ?? [],
+      ...options.commands?.names ?? [],
       "help",
       "tools",
       "describe",
@@ -566,26 +586,25 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
     ]);
     return fail(`Unknown command: ${command}.${suggestion ? ` Did you mean ${suggestion}?` : ""}`);
   }
-  if (command === "describe") {
+  if (command === "describe" || args.includes("--help") || args.includes("-h")) {
     stdout.write(
       `${tool.name}
+Usage: ${options.bin} ${tool.name} --parameter value [--json]
 ${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")}
+${schemaRows(tool.inputSchema).join("\n")}
 
 ${JSON.stringify(tool.inputSchema, null, 2)}
 `
     );
     return 0;
   }
+  const json = args.includes("--json");
+  if (!plain && json) args.splice(args.indexOf("--json"), 1);
   let input = {};
   try {
     const readStdin = async () => {