sysprom 1.0.6 → 1.1.0

package/README.md

@@ -23,38 +23,38 @@ Both `sysprom` and `spm` are available as commands.
 
 ```sh
 # Convert between formats
-spm json2md sysprom.spm.json ./SysProM
-spm md2json ./SysProM output.spm.json
+spm json2md .spm.json ./.spm
+spm md2json ./.spm output.spm.json
 
-# Validate and summarise
-spm validate sysprom.spm.json
-spm stats sysprom.spm.json
+# Validate and summarise (auto-detects .spm.json in current directory)
+spm validate
+spm stats
 
 # Query nodes and relationships
-spm query nodes sysprom.spm.json --type decision
-spm query node sysprom.spm.json D1
-spm query rels sysprom.spm.json --from D1
-spm query trace sysprom.spm.json I1
-spm query timeline sysprom.spm.json
-spm query state-at sysprom.spm.json --time 2026-03-22
+spm query nodes --type decision
+spm query node D1
+spm query rels --from D1
+spm query trace I1
+spm query timeline
+spm query state-at 2026-03-22
 
 # Add nodes (ID auto-generated from type prefix if --id omitted)
-spm add sysprom.spm.json invariant --name "New Rule" --description "Must hold"
-spm add sysprom.spm.json decision --name "Choose X" \
+spm add invariant --name "New Rule" --description "Must hold"
+spm add decision --name "Choose X" \
   --option "OPT-A:Use framework X" --option "OPT-B:Use framework Y" \
   --selected OPT-A --rationale "Lower migration effort"
 
 # Remove nodes
-spm remove sysprom.spm.json INV23
+spm remove INV23
 
 # Update nodes, relationships, and metadata
-spm update node sysprom.spm.json D1 --status deprecated
-spm update add-rel sysprom.spm.json D1 affects EL5
-spm update remove-rel sysprom.spm.json D1 affects EL5
-spm update meta sysprom.spm.json --meta version=2
+spm update node D1 --status deprecated
+spm update add-rel D1 affects EL5
+spm update remove-rel D1 affects EL5
+spm update meta --fields version=2
 ```
 
-All commands auto-detect format — they work on `.spm.json` files, `.spm.md` files, and multi-document folders.
+All commands auto-detect the document — they search the current directory for `.spm.json`, `.spm.md`, or `.spm/` (in that priority order), then fall back to `*.spm.json`, `*.spm.md`, or `*.spm/`. Use `--path` to specify an explicit path.
 
 ## Programmatic API
 
@@ -101,7 +101,7 @@ import {
 } from "sysprom";
 
 // Validate
-const doc = JSON.parse(fs.readFileSync("sysprom.spm.json", "utf8"));
+const doc = JSON.parse(fs.readFileSync(".spm.json", "utf8"));
 const result = validate(doc);
 console.log(result.valid, result.issues);
 
@@ -139,6 +139,7 @@ SysProM models systems as directed graphs across abstraction layers — intent,
 | [RFC Processes](https://www.rfc-editor.org/rfc/rfc2026) | ✅ | | | ✅ | 🔶 | | | | | | | | 🔶 | 🔶 |
 | [Ralplan](https://github.com/yeachan-heo/oh-my-claudecode/blob/main/skills/ralplan/SKILL.md) | ✅ | | 🔶 | ✅ | | 🔶 | | | | | | | ✅ | 🔶 |
 | [GSD](https://github.com/gsd-build/get-shit-done) | ✅ | | | 🔶 | | 🔶 | | | | | | | | |
+| [Superpowers](https://github.com/obra/superpowers) | ✅ | 🔶 | 🔶 | 🔶 | 🔶 | ✅ | 🔶 | | ✅ | 🔶 | | ✅ | ✅ | ✅ |
 | **SysProM** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | 🔶 | | 🔶 | ✅ | ✅ | ✅ | ✅ |
 
 ✅ = first-class support. 🔶 = partial or implicit.
@@ -182,26 +183,26 @@ pnpm spm <command>    # Run the CLI from source (e.g. pnpm spm validate ...)
 
 ## Self-Description
 
-`sysprom.spm.json` is SysProM describing itself — the specification, its decisions, invariants, changes, and worked examples are all encoded as a SysProM document. The `./SysProM/` folder contains the same content as human-readable Markdown.
+`.spm.json` is SysProM describing itself — the specification, its decisions, invariants, changes, and worked examples are all encoded as a SysProM document. The `./.spm/` folder contains the same content as human-readable Markdown.
 
-All significant activity — decisions, changes, new capabilities, and invariants — should be recorded in the self-describing document. Updates can be made either by editing the Markdown files in `./SysProM/` directly or by using the CLI:
+All significant activity — decisions, changes, new capabilities, and invariants — should be recorded in the self-describing document. Updates can be made either by editing the Markdown files in `./.spm/` directly or by using the CLI:
 
 ```sh
 # Add a decision via the CLI
-spm add sysprom.spm.json decision --id D23 --name "My Decision" --context "Why this was needed"
+spm add decision --id D23 --name "My Decision" --context "Why this was needed"
 
-# Or edit ./SysProM/DECISIONS.md directly, then sync
-spm md2json ./SysProM sysprom.spm.json
+# Or edit ./.spm/DECISIONS.md directly, then sync
+spm md2json ./.spm .spm.json
 ```
 
 Keep both representations in sync after any change:
 
 ```sh
 # JSON → Markdown
-spm json2md sysprom.spm.json ./SysProM
+spm json2md .spm.json ./.spm
 
 # Markdown → JSON
-spm md2json ./SysProM sysprom.spm.json
+spm md2json ./.spm .spm.json
 ```
 
-> **Important:** Always keep `sysprom.spm.json` and `./SysProM/` up to date with current activity and in sync with each other. Record all decisions, changes, and new capabilities as they happen. After any change to either representation, run the appropriate conversion command above. Validate with `spm validate sysprom.spm.json` before committing.
+> **Important:** Always keep `.spm.json` and `./.spm/` up to date with current activity and in sync with each other. Record all decisions, changes, and new capabilities as they happen. After any change to either representation, run the appropriate conversion command above. Validate with `spm validate` before committing.

package/dist/src/canonical-json.d.ts

@@ -10,7 +10,9 @@
  * - null, true, false as literals
  * - undefined values omitted from objects
  */
+/** Options for controlling canonical JSON output formatting. */
 export interface FormatOptions {
+    /** Indentation string (e.g. `"\t"` or `"  "`). Empty string produces compact output. */
     indent?: string;
 }
 /**

package/dist/src/cli/commands/add.d.ts

@@ -1,10 +1,10 @@
 import * as z from "zod";
 import type { CommandDef } from "../define-command.js";
 declare const argsSchema: z.ZodObject<{
-    input: z.ZodString;
     nodeType: z.ZodString;
 }, z.core.$strip>;
 declare const optsSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
     json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sync: z.ZodOptional<z.ZodString>;

package/dist/src/cli/commands/add.js

@@ -1,9 +1,8 @@
 import * as z from "zod";
 import { NodeType, NodeStatus } from "../../schema.js";
 import { addNodeOp, nextIdOp } from "../../operations/index.js";
-import { inputArg, mutationOpts, loadDoc, persistDoc } from "../shared.js";
+import { mutationOpts, loadDoc, persistDoc } from "../shared.js";
 const argsSchema = z.object({
-    input: inputArg,
     nodeType: z.string().describe("Node type to add"),
 });
 const optsSchema = mutationOpts.extend({
@@ -31,7 +30,7 @@ export const addCommand = {
             console.error("--name is required.");
             process.exit(1);
         }
-        const loaded = loadDoc(args.input);
+        const loaded = loadDoc(opts.path);
         const { doc } = loaded;
         const type = args.nodeType;
         if (!NodeType.is(type)) {

package/dist/src/cli/commands/check.d.ts

@@ -1,10 +1,8 @@
-import * as z from "zod";
 import type { CommandDef } from "../define-command.js";
-declare const argsSchema: z.ZodObject<{
-    input: z.ZodString;
-}, z.core.$strip>;
-declare const optsSchema: z.ZodObject<{
-    json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
-export declare const checkCommand: CommandDef<typeof argsSchema, typeof optsSchema>;
+import { noArgs } from "../shared.js";
+declare const optsSchema: import("zod").ZodObject<{
+    path: import("zod").ZodOptional<import("zod").ZodString>;
+    json: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+}, import("zod/v4/core").$strip>;
+export declare const checkCommand: CommandDef<typeof noArgs, typeof optsSchema>;
 export {};

package/dist/src/cli/commands/check.js

@@ -1,18 +1,13 @@
-import * as z from "zod";
 import { checkOp } from "../../operations/index.js";
-import { inputArg, readOpts, loadDoc } from "../shared.js";
-const argsSchema = z.object({
-    input: inputArg,
-});
+import { readOpts, loadDoc } from "../shared.js";
 const optsSchema = readOpts;
 export const checkCommand = {
     name: "check",
     description: checkOp.def.description,
     apiLink: checkOp.def.name,
-    args: argsSchema,
     opts: optsSchema,
-    action(args, opts) {
-        const { doc } = loadDoc(args.input);
+    action(_args, opts) {
+        const { doc } = loadDoc(opts.path);
         const result = checkOp({ doc });
         if (opts.json) {
             console.log(JSON.stringify(result, null, 2));

package/dist/src/cli/commands/graph.d.ts

@@ -1,9 +1,8 @@
 import * as z from "zod";
 import type { CommandDef } from "../define-command.js";
-declare const argsSchema: z.ZodObject<{
-    input: z.ZodString;
-}, z.core.$strip>;
+import { noArgs } from "../shared.js";
 declare const optsSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
     json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     format: z.ZodOptional<z.ZodEnum<{
         dot: "dot";
@@ -11,5 +10,5 @@ declare const optsSchema: z.ZodObject<{
     }>>;
     type: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const graphCommand: CommandDef<typeof argsSchema, typeof optsSchema>;
+export declare const graphCommand: CommandDef<typeof noArgs, typeof optsSchema>;
 export {};

package/dist/src/cli/commands/graph.js

@@ -1,9 +1,6 @@
 import * as z from "zod";
 import { graphOp } from "../../operations/index.js";
-import { inputArg, readOpts, loadDoc } from "../shared.js";
-const argsSchema = z.object({
-    input: inputArg,
-});
+import { readOpts, loadDoc } from "../shared.js";
 const optsSchema = readOpts.extend({
     format: z.enum(["mermaid", "dot"]).optional().describe("Output format"),
     type: z.string().optional().describe("Filter by relationship type"),
@@ -12,11 +9,10 @@ export const graphCommand = {
     name: "graph",
     description: graphOp.def.description,
     apiLink: graphOp.def.name,
-    args: argsSchema,
     opts: optsSchema,
-    action(args, opts) {
+    action(_args, opts) {
         try {
-            const { doc } = loadDoc(args.input);
+            const { doc } = loadDoc(opts.path);
             const output = graphOp({
                 doc,
                 format: opts.format ?? "mermaid",

package/dist/src/cli/commands/init.d.ts

@@ -1,2 +1,16 @@
+import * as z from "zod";
 import type { CommandDef } from "../define-command.js";
-export declare const initCommand: CommandDef;
+declare const argsSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const optsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        dir: "dir";
+        json: "json";
+        md: "md";
+    }>>;
+}, z.core.$strict>;
+export declare const initCommand: CommandDef<typeof argsSchema, typeof optsSchema>;
+export {};

package/dist/src/cli/commands/init.js

@@ -1,44 +1,74 @@
 import * as z from "zod";
-import { writeFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { canonicalise } from "../../canonical-json.js";
+import { existsSync, statSync } from "node:fs";
+import { resolve, join } from "node:path";
 import { initDocumentOp } from "../../operations/index.js";
-function isArgs(arg) {
-    return typeof arg === "object" && arg !== null && "output" in arg;
+import { saveDocument } from "../../io.js";
+const formatChoices = ["json", "md", "dir"];
+function formatToIoFormat(fmt) {
+    switch (fmt) {
+        case "json":
+            return "json";
+        case "md":
+            return "single-md";
+        case "dir":
+            return "multi-md";
+    }
 }
-function isOpts(opt) {
-    return typeof opt === "object" && opt !== null;
+const suffixMap = {
+    json: ".spm.json",
+    md: ".spm.md",
+    dir: ".spm",
+};
+function resolveInitTarget(pathArg, format) {
+    const resolved = resolve(pathArg);
+    const isExistingDir = existsSync(resolved) && statSync(resolved).isDirectory();
+    if (isExistingDir) {
+        const fmt = format ?? "json";
+        return {
+            outputPath: join(resolved, suffixMap[fmt]),
+            ioFormat: formatToIoFormat(fmt),
+        };
+    }
+    const fmt = format ?? "dir";
+    return {
+        outputPath: `${resolved}${suffixMap[fmt]}`,
+        ioFormat: formatToIoFormat(fmt),
+    };
 }
+const argsSchema = z.object({
+    path: z
+        .string()
+        .optional()
+        .default(".")
+        .describe("Target path (default: current directory)"),
+});
+const optsSchema = z
+    .object({
+    title: z.string().optional().describe("Document title"),
+    scope: z.string().optional().describe("Document scope"),
+    format: z
+        .enum(formatChoices)
+        .optional()
+        .describe("Output format: json, md, or dir"),
+})
+    .strict();
 export const initCommand = {
     name: "init",
     description: initDocumentOp.def.description,
     apiLink: initDocumentOp.def.name,
-    args: z.object({
-        output: z.string().describe("Output file path"),
-    }),
-    opts: z
-        .object({
-        title: z.string().optional().describe("Document title"),
-        scope: z.string().optional().describe("Document scope"),
-    })
-        .strict(),
+    args: argsSchema,
+    opts: optsSchema,
     action(args, opts) {
-        if (!isArgs(args))
-            throw new Error("Invalid args");
-        if (!isOpts(opts))
-            throw new Error("Invalid opts");
-        const typedArgs = args;
-        const typedOpts = opts;
-        const outputPath = resolve(typedArgs.output);
+        const { outputPath, ioFormat } = resolveInitTarget(args.path, opts.format);
         if (existsSync(outputPath)) {
-            console.error(`File already exists: ${outputPath}`);
+            console.error(`Already exists: ${outputPath}`);
             process.exit(1);
         }
         const doc = initDocumentOp({
-            title: typedOpts.title ?? "Untitled",
-            scope: typedOpts.scope ?? "system",
+            title: opts.title ?? "Untitled",
+            scope: opts.scope ?? "system",
         });
-        writeFileSync(outputPath, canonicalise(doc, { indent: "\t" }) + "\n");
+        saveDocument(doc, ioFormat, outputPath);
         console.log(`Created ${outputPath}`);
     },
 };

package/dist/src/cli/commands/plan.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { existsSync } from "node:fs";
-import { loadDocument, saveDocument } from "../../io.js";
+import { saveDocument } from "../../io.js";
+import { loadDoc, mutationOpts, persistDoc } from "../shared.js";
 import { planInitOp, planAddTaskOp, planStatusOp, planProgressOp, planGateOp, } from "../../operations/index.js";
 // ============================================================================
 // Subcommands
@@ -37,10 +38,7 @@ const initSubcommand = {
         }
     },
 };
-const addTaskArgs = z.object({
-    input: z.string().describe("Path to SysProM document"),
-});
-const addTaskOpts = z.object({
+const addTaskOpts = mutationOpts.pick({ path: true }).extend({
     prefix: z.string().describe("Plan prefix"),
     name: z.string().optional().describe("Task name"),
     parent: z.string().optional().describe("Parent task ID"),
@@ -49,17 +47,20 @@ const addTaskSubcommand = {
     name: "add-task",
     description: planAddTaskOp.def.description,
     apiLink: planAddTaskOp.def.name,
-    args: addTaskArgs,
     opts: addTaskOpts,
-    action(args, opts) {
-        const inputPath = args.input;
+    action(_args, opts) {
         const prefix = opts.prefix;
         const name = opts.name;
         const parentId = opts.parent;
         try {
-            const { doc, format, path } = loadDocument(inputPath);
-            const newDoc = planAddTaskOp({ doc, prefix, name, parent: parentId });
-            saveDocument(newDoc, format, path);
+            const loaded = loadDoc(opts.path);
+            const newDoc = planAddTaskOp({
+                doc: loaded.doc,
+                prefix,
+                name,
+                parent: parentId,
+            });
+            persistDoc(newDoc, loaded, { ...opts, json: false, dryRun: false });
             const target = parentId ? `to ${parentId}` : `to ${prefix}-PROT-IMPL`;
             console.log(`Added task ${target}`);
         }
@@ -69,10 +70,7 @@ const addTaskSubcommand = {
         }
     },
 };
-const statusArgs = z.object({
-    input: z.string().describe("Path to SysProM document"),
-});
-const statusOpts = z.object({
+const statusOpts = mutationOpts.pick({ path: true }).extend({
     prefix: z.string().describe("Plan prefix"),
     json: z.boolean().optional().describe("Output as JSON"),
 });
@@ -80,20 +78,17 @@ const statusSubcommand = {
     name: "status",
     description: planStatusOp.def.description,
     apiLink: planStatusOp.def.name,
-    args: statusArgs,
     opts: statusOpts,
-    action(args, opts) {
-        const inputPath = args.input;
+    action(_args, opts) {
         const prefix = opts.prefix;
         const asJson = opts.json === true;
         try {
-            const { doc } = loadDocument(inputPath);
+            const { doc } = loadDoc(opts.path);
             const status = planStatusOp({ doc, prefix });
             if (asJson) {
                 console.log(JSON.stringify(status, null, 2));
                 return;
             }
-            // Format: Constitution, Spec, Plan, Tasks, Checklist status report
             const formatBoolean = (defined) => defined ? "✅ defined" : "❌ not defined";
             console.log(`Constitution: ${formatBoolean(status.constitution.defined)} (${String(status.constitution.principleCount)} principles)`);
             console.log(`Spec:         ${formatBoolean(status.spec.defined)} (${String(status.spec.userStoryCount)} user stories)`);
@@ -109,10 +104,7 @@ const statusSubcommand = {
         }
     },
 };
-const progressArgs = z.object({
-    input: z.string().describe("Path to SysProM document"),
-});
-const progressOpts = z.object({
+const progressOpts = mutationOpts.pick({ path: true }).extend({
     prefix: z.string().describe("Plan prefix"),
     json: z.boolean().optional().describe("Output as JSON"),
 });
@@ -120,21 +112,17 @@ const progressSubcommand = {
     name: "progress",
     description: planProgressOp.def.description,
     apiLink: planProgressOp.def.name,
-    args: progressArgs,
     opts: progressOpts,
-    action(args, opts) {
-        const inputPath = args.input;
+    action(_args, opts) {
         const prefix = opts.prefix;
         const asJson = opts.json === true;
         try {
-            const { doc } = loadDocument(inputPath);
+            const { doc } = loadDoc(opts.path);
             const progress = planProgressOp({ doc, prefix });
             if (asJson) {
                 console.log(JSON.stringify(progress, null, 2));
                 return;
             }
-            // Format: ASCII progress bars
-            // Bar width: 10 chars. Filled: █, empty: ░. Name padded to 20 chars. Percent right-aligned to 3 chars.
             for (const phase of progress) {
                 const filledCount = Math.round((phase.percent / 100) * 10);
                 const emptyCount = 10 - filledCount;
@@ -151,10 +139,7 @@ const progressSubcommand = {
         }
     },
 };
-const gateArgs = z.object({
-    input: z.string().describe("Path to SysProM document"),
-});
-const gateOpts = z.object({
+const gateOpts = mutationOpts.pick({ path: true }).extend({
     prefix: z.string().describe("Plan prefix"),
     phase: z.string().describe("Phase number"),
     json: z.boolean().optional().describe("Output as JSON"),
@@ -163,10 +148,8 @@ const gateSubcommand = {
     name: "gate",
     description: planGateOp.def.description,
     apiLink: planGateOp.def.name,
-    args: gateArgs,
     opts: gateOpts,
-    action(args, opts) {
-        const inputPath = args.input;
+    action(_args, opts) {
         const prefix = opts.prefix;
         const phaseNum = parseInt(opts.phase, 10);
         const asJson = opts.json === true;
@@ -175,13 +158,12 @@ const gateSubcommand = {
             process.exit(1);
         }
         try {
-            const { doc } = loadDocument(inputPath);
+            const { doc } = loadDoc(opts.path);
             const result = planGateOp({ doc, prefix, phase: phaseNum });
             if (asJson) {
                 console.log(JSON.stringify(result, null, 2));
                 return;
             }
-            // Format: Gate check result with detailed issues
             if (result.ready) {
                 console.log(`Gate check for phase ${String(phaseNum)}: ✅ READY`);
             }

package/dist/src/cli/commands/query.js

@@ -1,7 +1,7 @@
 import pc from "picocolors";
 import * as z from "zod";
 import { textToString } from "../../text.js";
-import { inputArg, readOpts, loadDoc } from "../shared.js";
+import { readOpts, loadDoc } from "../shared.js";
 import { queryNodesOp, queryNodeOp, queryRelationshipsOp, traceFromNodeOp, timelineOp, nodeHistoryOp, stateAtOp, } from "../../operations/index.js";
 import { NodeType, NodeStatus } from "../../schema.js";
 // ---------------------------------------------------------------------------
@@ -65,39 +65,27 @@ function printTraceTree(tn, depth) {
 // ---------------------------------------------------------------------------
 // Arg/opt schemas
 // ---------------------------------------------------------------------------
-const nodesArgs = z.object({
-    input: inputArg,
-});
 const nodesOpts = readOpts.extend({
     type: NodeType.optional().describe("filter by node type"),
     status: NodeStatus.optional().describe("filter by node status"),
 });
 const nodeArgs = z.object({
-    input: inputArg,
     id: z.string().describe("node ID to retrieve"),
 });
 const nodeOpts = readOpts;
-const relsArgs = z.object({
-    input: inputArg,
-});
 const relsOpts = readOpts.extend({
     from: z.string().optional().describe("filter relationships by source node"),
     to: z.string().optional().describe("filter relationships by target node"),
     type: z.string().optional().describe("filter by relationship type"),
 });
 const traceArgs = z.object({
-    input: inputArg,
     id: z.string().describe("node ID to start trace from"),
 });
 const traceOpts = readOpts;
-const timelineArgs = z.object({
-    input: inputArg,
-});
 const timelineOpts = readOpts.extend({
     node: z.string().optional().describe("filter events to a specific node"),
 });
 const stateAtArgs = z.object({
-    input: inputArg,
     time: z.string().describe("ISO timestamp to query"),
 });
 const stateAtOpts = readOpts;
@@ -108,12 +96,10 @@ const nodesSubcommand = {
     name: "nodes",
     description: queryNodesOp.def.description,
     apiLink: queryNodesOp.def.name,
-    args: nodesArgs,
     opts: nodesOpts,
-    action(rawArgs, rawOpts) {
-        const args = nodesArgs.parse(rawArgs);
+    action(_rawArgs, rawOpts) {
         const opts = nodesOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const nodes = queryNodesOp({ doc, type: opts.type, status: opts.status });
         if (opts.json) {
             console.log(JSON.stringify(nodes, null, 2));
@@ -134,7 +120,7 @@ const nodeSubcommand = {
     action(rawArgs, rawOpts) {
         const args = nodeArgs.parse(rawArgs);
         const opts = nodeOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const result = queryNodeOp({ doc, id: args.id });
         if (!result) {
             console.error(`Node not found: ${args.id}`);
@@ -162,12 +148,10 @@ const relsSubcommand = {
     name: "rels",
     description: queryRelationshipsOp.def.description,
     apiLink: queryRelationshipsOp.def.name,
-    args: relsArgs,
     opts: relsOpts,
-    action(rawArgs, rawOpts) {
-        const args = relsArgs.parse(rawArgs);
+    action(_rawArgs, rawOpts) {
         const opts = relsOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const rels = queryRelationshipsOp({
             doc,
             from: opts.from,
@@ -194,7 +178,7 @@ const traceSubcommand = {
     action(rawArgs, rawOpts) {
         const args = traceArgs.parse(rawArgs);
         const opts = traceOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const trace = traceFromNodeOp({ doc, startId: args.id });
         if (opts.json) {
             console.log(JSON.stringify(trace, null, 2));
@@ -208,12 +192,10 @@ const timelineSubcommand = {
     name: "timeline",
     description: timelineOp.def.description,
     apiLink: timelineOp.def.name,
-    args: timelineArgs,
     opts: timelineOpts,
-    action(rawArgs, rawOpts) {
-        const args = timelineArgs.parse(rawArgs);
+    action(_rawArgs, rawOpts) {
         const opts = timelineOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const events = opts.node
             ? nodeHistoryOp({ doc, nodeId: opts.node })
             : timelineOp({ doc });
@@ -241,7 +223,7 @@ const stateAtSubcommand = {
     action(rawArgs, rawOpts) {
         const args = stateAtArgs.parse(rawArgs);
         const opts = stateAtOpts.parse(rawOpts);
-        const { doc } = loadDoc(args.input);
+        const { doc } = loadDoc(opts.path);
         const result = stateAtOp({ doc, timestamp: args.time });
         if (opts.json) {
             console.log(JSON.stringify(result, null, 2));

package/dist/src/cli/commands/remove.d.ts

@@ -1,10 +1,10 @@
 import * as z from "zod";
 import type { CommandDef } from "../define-command.js";
 declare const argsSchema: z.ZodObject<{
-    input: z.ZodString;
     nodeId: z.ZodString;
 }, z.core.$strip>;
 declare const optsSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
     json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sync: z.ZodOptional<z.ZodString>;