@ghostpaw/questlog 0.9.1 → 0.10.1

package/dist/chunk-QYSIJ2YN.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// src/surfaces/schema_actions.ts
+var requirements = /* @__PURE__ */ new WeakMap();
+function registerSchemaActions(schema, actions) {
+  requirements.set(schema, actions);
+}
+function requiredForAction(schema, action) {
+  return requirements.get(schema)?.[String(action)] ?? [];
+}
+
+// src/surfaces/schema_examples.ts
+function minimalInput(schema, action, name = "") {
+  const constant = "const" in schema ? schema.const : void 0;
+  if (constant !== void 0) return constant;
+  if (schema.enum)
+    return action !== void 0 && schema.enum.includes(action) ? action : schema.enum[0];
+  const branch = schema.oneOf?.[0];
+  if (schema.type === "object" || schema.properties) {
+    action ??= schema.properties?.action?.enum?.[0];
+    const properties = { ...schema.properties, ...branch?.properties };
+    return Object.fromEntries(
+      [
+        .../* @__PURE__ */ new Set([
+          ...schema.required ?? [],
+          ...requiredForAction(schema, action),
+          ...schema.properties?.outcome && ["finish", "abandon", "abandon_and_spawn_followups"].includes(String(action)) ? ["outcome"] : [],
+          ...branch?.required ?? []
+        ])
+      ].map((key) => [
+        key,
+        minimalInput(properties[key] ?? {}, key === "action" ? action : void 0, key)
+      ])
+    );
+  }
+  if (branch) return minimalInput(branch, action, name);
+  if (schema.type === "array") return [minimalInput(schema.items ?? {}, void 0, name)];
+  if (schema.type === "integer" || schema.type === "number")
+    return name === "anchorAt" ? 18e11 : name === "toQuestId" ? 2 : 1;
+  if (schema.type === "boolean") return false;
+  if (schema.type === "null") return null;
+  if (name === "rrule") return "FREQ=WEEKLY";
+  if (name === "title") return "Review release notes";
+  if (name === "objective") return "Check changes against the release";
+  return "release";
+}
+
+export { minimalInput, registerSchemaActions, requiredForAction };

package/dist/{chunk-3B6FMHZU.js → chunk-ZHTX64KD.js}

@@ -2,6 +2,29 @@
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 
+// src/hooks/init_hook_tables.ts
+function initHookTables(db) {
+  db.exec(`
+ CREATE TABLE IF NOT EXISTS hook_targets (
+ id INTEGER PRIMARY KEY AUTOINCREMENT, url TEXT NOT NULL, secret TEXT NOT NULL,
+ tag TEXT, events TEXT NOT NULL, min_gap INTEGER NOT NULL, created_at INTEGER NOT NULL,
+ last_wake INTEGER, lease_until INTEGER, claim TEXT);
+ CREATE TABLE IF NOT EXISTS hook_events (
+ id TEXT PRIMARY KEY, occurred_at INTEGER NOT NULL, event TEXT NOT NULL);
+ CREATE TABLE IF NOT EXISTS hook_assignments (
+ target_id INTEGER NOT NULL REFERENCES hook_targets(id) ON DELETE CASCADE,
+ event_id TEXT NOT NULL REFERENCES hook_events(id), delivery_id TEXT,
+ PRIMARY KEY(target_id, event_id));
+ CREATE TABLE IF NOT EXISTS hook_deliveries (
+ id TEXT PRIMARY KEY, target_id INTEGER NOT NULL REFERENCES hook_targets(id) ON DELETE CASCADE,
+ events TEXT NOT NULL, status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0,
+ last_attempt_at INTEGER, http_status INTEGER, error_class TEXT,
+ next_attempt_at INTEGER NOT NULL);
+ CREATE INDEX IF NOT EXISTS idx_hook_deliveries_target ON hook_deliveries(target_id, status, next_attempt_at);
+ CREATE TABLE IF NOT EXISTS hook_settings (id INTEGER PRIMARY KEY CHECK(id = 1), label TEXT NOT NULL);
+ `);
+}
+
 // src/questlines/init_questline_tables.ts
 function initQuestlineTables(db) {
   db.exec(`
@@ -350,6 +373,7 @@ function initQuestlogTables(db) {
   initTagTables(db);
   initQuestSearch(db);
   initRumorSearch(db);
+  initHookTables(db);
 }
 
 // src/surface/open_questlog_db.ts

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-ELAKW6KW.js');
+  await import('./cli_main-7AIEZV75.js');
 }

package/dist/{cli_main-ELAKW6KW.js → cli_main-7AIEZV75.js}

@@ -1,111 +1,36 @@
 #!/usr/bin/env node
-import { validateInput, isErrorResult, questlogVersion, resolveQuestlogDbPath } from './chunk-KRQDV4KF.js';
-import { reviewQuestlogTool, getQuestDetail, questlogSurfaceTools } from './chunk-3Y5F3SMB.js';
-import { readFileSync, existsSync } from 'node:fs';
+import { CliUsageError, renderCliHelp, parseCliArgs } from './chunk-GVD6A3RR.js';
+import { isErrorResult, resolveQuestlogDbPath } from './chunk-IL2QRKZL.js';
+import { questlogSkills } from './chunk-D2W5MYNO.js';
+import { reviewQuestlogTool, validateInput, getQuestDetail, questlogSurfaceTools } from './chunk-55JAQORX.js';
+import { listDeliveries, questlogVersion } from './chunk-N7V7VUI5.js';
+import { minimalInput } from './chunk-QYSIJ2YN.js';
+import { isSea } from 'node:sea';
+import { 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;
+var npmEntry = false;
+function markNpmEntry() {
+  npmEntry = true;
 }
-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")}
-`;
+function cliVersion(version, {
+  sea = isSea,
+  npm = npmEntry,
+  platform = process.platform,
+  arch = process.arch,
+  args = []
+} = {}) {
+  let binary = false;
+  try {
+    binary = sea();
+  } 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"})`;
 }
 
 // src/surface/plain_dates.ts
@@ -189,6 +114,8 @@ 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 `${JSON.stringify(r.data.deliveries, null, 2)}
 `;
   if (r.data.items) {
     const items = values.limit === void 0 ? r.data.items : r.data.items.slice(0, Math.max(0, Number(values.limit)));
@@ -214,6 +141,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")}
 `;
@@ -237,12 +169,41 @@ 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",
-        description: "Create a quest. Objective defaults to the title.",
+        description: 'Create a quest: add "My title" or add --title "My title". Objective defaults to the title.',
+        positionals: [{ name: "positionalTitle", type: "string" }],
         flags: [
-          { name: "title", type: "string", required: true },
+          { name: "title", type: "string" },
           { name: "tag", type: "array" },
           { name: "objective", type: "string" },
           {
@@ -255,9 +216,15 @@ function questlogPlainCommands() {
       },
       tool: "shape_work",
       input: (v) => {
+        if (v.title !== void 0 && v.positionalTitle !== void 0)
+          throw new CliUsageError(
+            "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");
         const quest = {
-          title: v.title,
-          objective: v.objective ?? v.title
+          title,
+          objective: v.objective ?? title
         };
         if (v.tag !== void 0)
           quest.tags = v.tag.flatMap(
@@ -342,12 +309,13 @@ function selectedDbPath(options) {
 var questlogCliOptions = {
   bin: "ghostpaw-questlog",
   version: 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-LAEH7UDM.js');
     const path = selectedDbPath(options);
     const created = path !== ":memory:" && !existsSync(path);
     const db = await openQuestlogDb(path);
@@ -357,14 +325,24 @@ 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 !== "hook" && command !== "watch") return void 0;
+      const { runHookCommand } = await import('./run_hook_command-C42BQC36.js');
+      return runHookCommand(command, args, io, async () => {
+        const { openQuestlogDb } = await import('./open_questlog_db-LAEH7UDM.js');
+        return openQuestlogDb(selectedDbPath(options));
+      });
+    },
     plain: questlogPlainCommands(),
+    guides: questlogSkills,
     mcp: async (options) => {
-      const { serveQuestlogMcp } = await import('./serve_questlog_mcp-QSHMNNFT.js');
+      const { serveQuestlogMcp } = await import('./serve_questlog_mcp-W3R63HW4.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-LOQ2FNOF.js');
+      const { renderSkillMarkdown } = await import('./skill_markdown-HXYQ3K6U.js');
+      const { questlogSkillSpec } = await import('./questlog_skill_spec-HEW2B6EB.js');
       return renderSkillMarkdown(questlogSkillSpec);
     }
   }
@@ -433,6 +411,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();
@@ -442,8 +426,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")}
@@ -451,11 +441,6 @@ ${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(
@@ -470,7 +455,26 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
   }
   if (command === "skill") {
     if (!options.commands?.skill) return fail("skill command unavailable");
-    stdout.write(await options.commands.skill());
+    if (args.length > 1) return fail(`Usage: ${options.bin} skill [--list | <guide> | --help]`);
+    const guide = args[0];
+    if (guide === "--help" || guide === "-h") {
+      stdout.write(
+        `Usage:
+  ${options.bin} skill
+  ${options.bin} skill --list
+  ${options.bin} skill <guide>
+`
+      );
+    } else if (guide === "--list") {
+      stdout.write(
+        `${(options.commands.guides ?? []).map((entry) => `${entry.name}  ${entry.description.replace(/\s+/g, " ")}`).join("\n")}
+`
+      );
+    } else if (guide) {
+      const entry = options.commands.guides?.find((entry2) => entry2.name === guide);
+      if (!entry) return fail(`unknown guide ${guide}; run ${options.bin} skill --list`);
+      stdout.write(entry.content);
+    } else stdout.write(await options.commands.skill());
     return 0;
   }
   if (command === "mcp") {
@@ -478,6 +482,12 @@ ${options.tools.map((tool2) => `${tool2.name}  ${tool2.description}`).join("\n")
     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) {
@@ -507,6 +517,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",
@@ -599,7 +610,11 @@ ${JSON.stringify(tool.inputSchema, null, 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);
+  if (errors.length)
+    return fail(
+      `${errors.join("\n")}; pass ${JSON.stringify(minimalInput(tool.inputSchema, input?.action))}`,
+      1
+    );
   let context;
   try {
     context = await options.openContext(ctxOptions);
@@ -623,4 +638,5 @@ ${JSON.stringify(tool.inputSchema, null, 2)}
 }
 
 // src/cli_main.ts
+markNpmEntry();
 process.exitCode = await runToolCli(process.argv.slice(2), questlogCliOptions);