@ghostpaw/questlog 0.9.1 → 0.10.1

package/dist/open_questlog_db-LAEH7UDM.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { openQuestlogDb } from './chunk-ZHTX64KD.js';

package/dist/questlog_skill_spec-HEW2B6EB.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { questlogMcpInstructions } from './chunk-SVWAEAKC.js';
+import { questlogSkills } from './chunk-D2W5MYNO.js';
+import { reviewQuestlogTool, questlogSurfaceTools } from './chunk-55JAQORX.js';
+import './chunk-N7V7VUI5.js';
+import './chunk-QYSIJ2YN.js';
+
+// src/soul.ts
+var questlogSoulTraits = [
+  {
+    principle: "Store the least committed truth first.",
+    provenance: "The worst downstream errors usually start upstream: vague asks are turned into quests, soft ideas become fake deadlines, and half-understood work is treated as fully shaped. Using rumors and clarification before commitment keeps uncertainty where it belongs."
+  },
+  {
+    principle: "Read before you prescribe.",
+    provenance: "Many management mistakes are category mistakes: blocked work gets treated as available, missed schedule as overdue, or resolved work as fully closed when follow-through still remains. Reading the derived state first prevents confident but wrong interventions."
+  },
+  {
+    principle: "Protect history when reality changes.",
+    provenance: "Once execution starts, rewriting a quest into a different commitment destroys the meaning of the record. Honest finishes, abandonments, and follow-up quests preserve what actually happened and keep later review, planning, and reporting trustworthy."
+  },
+  {
+    principle: "Close the last mile, not just the main work.",
+    provenance: "Operational debt often hides in almost-done states: work finished but not claimed, reported, handed off, reviewed, or retired. Treating closure as a real phase prevents stale rewards, lingering initiatives, and misleading progress signals."
+  }
+];
+
+// src/surface/questlog_skill_spec.ts
+var questlogSkillSpec = {
+  name: "questlog",
+  cheatSheet: [
+    "## Install",
+    "",
+    "Linux/macOS:",
+    "",
+    "```sh",
+    "curl -fsSL https://raw.githubusercontent.com/GhostPawJS/questlog/main/install.sh | sh",
+    "```",
+    "",
+    "Installs `~/.local/bin/ghostpaw-questlog` after checking SHA256SUMS.",
+    "",
+    "Windows x64 (PowerShell):",
+    "",
+    "```powershell",
+    "irm https://raw.githubusercontent.com/GhostPawJS/questlog/main/install.ps1 | iex",
+    "```",
+    "",
+    "Run tools as `ghostpaw-questlog ...`; use `~/.local/bin/ghostpaw-questlog` if it is not on PATH.",
+    "",
+    "`questlog` and `ghostpaw-questlog` are the same binary.",
+    "",
+    "- `questlog search <words>` before `add` to avoid duplicates.",
+    '- `ghostpaw-questlog add "..." --tag a,b --due tomorrow`',
+    `- \`questlog list [--view <view>]\`: ${reviewQuestlogTool.inputSchema.properties?.view?.enum?.join(", ")}.`,
+    '- `questlog done <id> --outcome "..."`',
+    "- `questlog search <words>`",
+    "- `questlog show <id>`",
+    "- Use `--json` on any plain command.",
+    "- Exit codes: 0 ok / 1 error / 2 usage / 3 needs input.",
+    "- Database: `~/.ghostpaw/questlog.db`; override with `--db` or `GHOSTPAW_QUESTLOG_DB`.",
+    "- Use one database per agent or project.",
+    "- Webhooks: `questlog hook add <url>`, `questlog tick --dry-run`, `questlog watch`. Read `questlog skill webhooks` for events, signing, verification, and cron setup."
+  ].join("\n"),
+  description: "Use the release binary ghostpaw-questlog to manage local tasks, calendar commitments, and recurring work. Use when planning, executing, reviewing, or organizing work.",
+  license: "MIT",
+  compatibility: "Release binary ghostpaw-questlog (no runtime needed); MCP stdio via ghostpaw-questlog mcp.",
+  bin: "ghostpaw-questlog",
+  packageName: "@ghostpaw/questlog",
+  server: "ghostpaw-questlog",
+  about: questlogMcpInstructions,
+  tools: questlogSurfaceTools,
+  workflows: questlogSkills,
+  principles: questlogSoulTraits.map((trait) => trait.principle)
+};
+
+export { questlogSkillSpec };

package/dist/run_hook_command-C42BQC36.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { parseCliArgs } from './chunk-GVD6A3RR.js';
+import { watchQuestlog, testHook, removeHook, hookLabel, listHooks, addHook } from './chunk-N7V7VUI5.js';
+
+// src/surface/run_hook_command.ts
+async function runHookCommand(command, args, io, open) {
+  let db;
+  try {
+    if (args.includes("--help") || args.includes("-h")) {
+      io.stdout.write(
+        "questlog hook add <url> [--tag name] [--events types] [--min-gap seconds] [--secret-stdin] [--json]\nquestlog hook list|remove <id>|test <id>|label [name]\nquestlog watch [--interval seconds] [--json]\n"
+      );
+      return 0;
+    }
+    const action = command === "watch" ? "watch" : args.shift();
+    if (!["add", "list", "remove", "test", "label", "watch"].includes(action ?? ""))
+      throw new Error("Expected hook add, list, remove, test, or label");
+    const values = parseCliArgs(args, {
+      command,
+      flags: [
+        { name: "json", type: "boolean" },
+        ...action === "add" ? [
+          { name: "tag", type: "string" },
+          { name: "events", type: "string" },
+          { name: "min-gap", type: "integer" },
+          { name: "secret-stdin", type: "boolean" }
+        ] : action === "watch" ? [{ name: "interval", type: "number" }] : []
+      ],
+      positionals: action === "add" ? [{ name: "url", type: "string", required: true }] : ["remove", "test"].includes(action ?? "") ? [{ name: "id", type: "integer", required: true }] : action === "label" ? [{ name: "name", type: "string" }] : []
+    });
+    if (action === "watch" && values.interval !== void 0 && Number(values.interval) < 5)
+      throw new Error("Interval must be at least 5 seconds");
+    db = await open();
+    let result;
+    switch (action) {
+      case "add": {
+        let secret;
+        if (values.secretStdin) {
+          secret = "";
+          for await (const chunk of io.stdin) secret += String(chunk);
+          secret = secret.replace(/\r?\n$/, "");
+        }
+        result = addHook(db, {
+          url: String(values.url),
+          ...values.tag === void 0 ? {} : { tag: String(values.tag) },
+          ...values.events === void 0 ? {} : { events: String(values.events).split(",") },
+          ...values.minGap === void 0 ? {} : { minGap: Number(values.minGap) },
+          ...secret === void 0 ? {} : { secret }
+        });
+        break;
+      }
+      case "list":
+        result = listHooks(db);
+        break;
+      case "label":
+        result = { label: hookLabel(db, values.name) };
+        break;
+      case "remove":
+        removeHook(db, Number(values.id));
+        result = { removed: Number(values.id) };
+        break;
+      case "test":
+        result = await testHook(db, Number(values.id));
+        break;
+      case "watch": {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        try {
+          await watchQuestlog(db, {
+            signal: controller.signal,
+            interval: Number(values.interval ?? 60),
+            onTick: (tick) => io.stdout.write(`${JSON.stringify(tick)}
+`)
+          });
+        } finally {
+          process.off("SIGINT", stop);
+          process.off("SIGTERM", stop);
+        }
+        return 0;
+      }
+    }
+    io.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return 0;
+  } catch {
+    io.stderr.write("Invalid webhook command or unavailable target. Run questlog hook --help.\n");
+    return 2;
+  } finally {
+    db?.close();
+  }
+}
+
+export { runHookCommand };

package/dist/{serve_questlog_mcp-QSHMNNFT.js → serve_questlog_mcp-W3R63HW4.js}

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
-import { openQuestlogDb } from './chunk-3B6FMHZU.js';
+import { openQuestlogDb } from './chunk-ZHTX64KD.js';
 import { questlogMcpInstructions } from './chunk-SVWAEAKC.js';
-import { validateInput, isErrorResult, questlogVersion, resolveQuestlogDbPath } from './chunk-KRQDV4KF.js';
-import { questlogSurfaceTools } from './chunk-3Y5F3SMB.js';
+import { isErrorResult, resolveQuestlogDbPath } from './chunk-IL2QRKZL.js';
+import { validateInput, questlogSurfaceTools } from './chunk-55JAQORX.js';
+import { questlogVersion } from './chunk-N7V7VUI5.js';
+import { minimalInput } from './chunk-QYSIJ2YN.js';
 
 // src/surfaces/mcp_server.ts
 var MCP_LATEST_PROTOCOL_VERSION = "2026-07-28";
@@ -103,7 +105,15 @@ Not for: ${tool.whenNotToUse}` : ""),
         const input = params.arguments === void 0 ? {} : params.arguments;
         const errors = validateInput(tool.inputSchema, input);
         if (errors.length)
-          return result({ content: [{ type: "text", text: errors.join("\n") }], isError: true });
+          return result({
+            content: [
+              {
+                type: "text",
+                text: `${errors.join("\n")}; pass ${JSON.stringify(minimalInput(tool.inputSchema, input?.action))}`
+              }
+            ],
+            isError: true
+          });
         try {
           context ??= Promise.resolve().then(options.context);
           const value = await tool.handler(await context, input);

package/dist/{skill_markdown-7HCMSJYR.js → skill_markdown-HXYQ3K6U.js}

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { minimalInput } from './chunk-QYSIJ2YN.js';
+
 // src/surfaces/skill_markdown.ts
 function renderSkillMarkdown(spec, { referencesBase = "references" } = {}) {
   if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(spec.name) || spec.name.length > 64)
@@ -26,7 +28,7 @@ function renderSkillMarkdown(spec, { referencesBase = "references" } = {}) {
     "",
     `MCP: connect to ${spec.server}, then call a tool by name with its JSON arguments.`,
     "",
-    `CLI: \`${spec.bin} call <tool> '<JSON object>'\` or \`${spec.bin} <tool> --parameter value\`${spec.packageName ? ` (without a global install: \`npx -y ${spec.packageName} <tool> ...\`)` : ""}.`,
+    `CLI: \`${spec.bin} call <tool> '<JSON object>'\` or \`${spec.bin} <tool> --parameter value\`.`,
     "",
     `Inspect schemas with \`${spec.bin} describe <tool>\`. Use \`--db <path>\` to select a database.`,
     ""
@@ -46,17 +48,38 @@ function renderSkillMarkdown(spec, { referencesBase = "references" } = {}) {
       "| Parameter | Type | Required | Values / description |",
       "| --- | --- | --- | --- |"
     );
-    for (const [name, property] of Object.entries(tool.inputSchema.properties ?? {}))
+    const rows = (schema, prefix = "") => {
+      const properties = { ...schema.properties };
+      const required = new Set(schema.required);
+      for (const branch of schema.oneOf ?? []) {
+        for (const [key, value] of Object.entries(branch.properties ?? {}))
+          properties[key] ??= value;
+        for (const key of branch.required ?? []) required.add(key);
+      }
+      for (const [name, property] of Object.entries(properties)) {
+        if (prefix && Object.keys(properties).length > 8 && !required.has(name)) continue;
+        const path = `${prefix}${name}`;
+        lines.push(
+          `| ${path} | ${property.type ?? property.oneOf?.map((branch) => branch.type).join(" / ") ?? "any"} | ${required.has(name) ? "yes" : "no"} | ${((property.enum ? `${property.enum.join(", ")}. ` : "") + (property.description ?? "")).replaceAll("|", "\\|").replaceAll("\n", " ")} |`
+        );
+        if (property.properties || property.oneOf) rows(property, `${path}.`);
+      }
+    };
+    rows(tool.inputSchema);
+    lines.push("", "```sh");
+    for (const action of tool.inputSchema.properties?.action?.enum?.slice(0, 3) ?? [void 0]) {
       lines.push(
-        `| ${name} | ${property.type ?? property.oneOf?.map((branch) => branch.type).join(" / ") ?? "any"} | ${tool.inputSchema.required?.includes(name) ? "yes" : "no"} | ${(property.enum ? `${property.enum.join(", ")}. ` : "") + (property.description ?? "").replaceAll("|", "\\|").replaceAll("\n", " ")} |`
+        `${spec.bin} call ${tool.name} '${JSON.stringify(minimalInput(tool.inputSchema, action))}'`
       );
+    }
+    lines.push("```");
     lines.push("");
   }
   lines.push(
     "## Workflow guides",
     "",
     ...spec.workflows.map(
-      (workflow) => `- [${workflow.name}](${referencesBase}/${workflow.name}.md): ${workflow.description}`
+      (workflow) => `- \`${spec.bin} skill ${workflow.name}\` ([${workflow.name}](${referencesBase}/${workflow.name}.md)): ${workflow.description}`
     ),
     "",
     "## Principles",
@@ -65,7 +88,12 @@ function renderSkillMarkdown(spec, { referencesBase = "references" } = {}) {
     ""
   );
   const output = lines.join("\n");
-  if (!spec.cheatSheet) return output;
+  const fallback = spec.packageName ? `
+## Without the binary
+
+Use \`npx -y ${spec.packageName} ...\` in npm-based environments (Node 24+). Harnesses that embed it in code can import \`${spec.packageName}\` as a library.
+` : "";
+  if (!spec.cheatSheet) return output + fallback;
   const title = `# ${spec.name}
 
 `;
@@ -74,7 +102,7 @@ function renderSkillMarkdown(spec, { referencesBase = "references" } = {}) {
 
 ## Appendix: MCP and tool calls
 
-${output.slice(start).replace(/^## /gm, "### ")}`;
+${output.slice(start).replace(/^## /gm, "### ")}${fallback}`;
 }
 
 export { renderSkillMarkdown };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ghostpaw/questlog",
-	"version": "0.9.1",
+	"version": "0.10.1",
 	"description": "Unified task and calendar model for Node.js — SQLite, zero dependencies, with a built-in LLM tool facade",
 	"type": "module",
 	"exports": {
@@ -127,7 +127,7 @@
 	"devDependencies": {
 		"@biomejs/biome": "2.4.4",
 		"@types/node": "^25.3.0",
-		"esbuild": "^0.27.4",
+		"esbuild": "^0.28.2",
 		"fflate": "0.8.3",
 		"preact": "^10.29.0",
 		"sql.js-fts5": "^1.4.0",
@@ -138,5 +138,8 @@
 		"ghostpaw-questlog": "./dist/cli.js",
 		"questlog": "./dist/cli.js"
 	},
-	"mcpName": "io.github.GhostPawJS/questlog"
+	"mcpName": "io.github.GhostPawJS/questlog",
+	"overrides": {
+		"esbuild": "$esbuild"
+	}
 }