sysprom 1.0.0 → 1.0.5

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

@@ -0,0 +1,275 @@
+import pc from "picocolors";
+import * as z from "zod";
+import { textToString } from "../../text.js";
+import { inputArg, readOpts, loadDoc } from "../shared.js";
+import { queryNodesOp, queryNodeOp, queryRelationshipsOp, traceFromNodeOp, timelineOp, nodeHistoryOp, stateAtOp, } from "../../operations/index.js";
+import { NodeType, NodeStatus } from "../../schema.js";
+// ---------------------------------------------------------------------------
+// Presentation helpers
+// ---------------------------------------------------------------------------
+function printNode(r, verbose) {
+    if (verbose) {
+        console.log(`${pc.cyan(r.id)} — ${pc.bold(r.name)}`);
+        console.log(`  ${pc.dim("Type")}: ${r.type}`);
+        if (r.status)
+            console.log(`  ${pc.dim("Status")}: ${pc.yellow(r.status)}`);
+        if (r.description)
+            console.log(`  ${pc.dim("Description")}: ${textToString(r.description)}`);
+        if (r.context)
+            console.log(`  ${pc.dim("Context")}: ${textToString(r.context)}`);
+        if (r.rationale)
+            console.log(`  ${pc.dim("Rationale")}: ${textToString(r.rationale)}`);
+        if (r.selected)
+            console.log(`  ${pc.dim("Selected")}: ${r.selected}`);
+        if (r.options) {
+            console.log(`  ${pc.dim("Options")}:`);
+            for (const o of r.options)
+                console.log(`    ${o.id}: ${textToString(o.description)}`);
+        }
+        if (r.scope)
+            console.log(`  ${pc.dim("Scope")}: ${r.scope.join(", ")}`);
+        if (r.lifecycle) {
+            const states = Object.entries(r.lifecycle)
+                .map(([k, v]) => `${k}=${String(v)}`)
+                .join(", ");
+            console.log(`  ${pc.dim("Lifecycle")}: ${states}`);
+        }
+        if (r.includes)
+            console.log(`  ${pc.dim("Includes")}: ${r.includes.join(", ")}`);
+        console.log("");
+    }
+    else {
+        const desc = r.description
+            ? " — " + textToString(r.description).slice(0, 60)
+            : "";
+        console.log(`${pc.cyan(r.id.padEnd(12))} ${pc.dim(r.type.padEnd(16))} ${pc.bold(r.name)}${desc}`);
+    }
+}
+function isTraceTreeNode(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return ("id" in value &&
+        typeof value.id === "string" &&
+        "children" in value &&
+        Array.isArray(value.children));
+}
+function printTraceTree(tn, depth) {
+    if (!tn.node)
+        return;
+    const indent = "  ".repeat(depth);
+    console.log(`${indent}${pc.cyan(tn.id)} — ${pc.bold(tn.node.name)} (${pc.dim(tn.node.type)})`);
+    for (const child of tn.children) {
+        printTraceTree(child, depth + 1);
+    }
+}
+// ---------------------------------------------------------------------------
+// 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;
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+const nodesSubcommand = {
+    name: "nodes",
+    description: queryNodesOp.def.description,
+    apiLink: queryNodesOp.def.name,
+    args: nodesArgs,
+    opts: nodesOpts,
+    action(rawArgs, rawOpts) {
+        const args = nodesArgs.parse(rawArgs);
+        const opts = nodesOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const nodes = queryNodesOp({ doc, type: opts.type, status: opts.status });
+        if (opts.json) {
+            console.log(JSON.stringify(nodes, null, 2));
+        }
+        else {
+            for (const n of nodes)
+                printNode(n, false);
+            console.log(`\n${String(nodes.length)} node(s)`);
+        }
+    },
+};
+const nodeSubcommand = {
+    name: "node",
+    description: queryNodeOp.def.description,
+    apiLink: queryNodeOp.def.name,
+    args: nodeArgs,
+    opts: nodeOpts,
+    action(rawArgs, rawOpts) {
+        const args = nodeArgs.parse(rawArgs);
+        const opts = nodeOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const result = queryNodeOp({ doc, id: args.id });
+        if (!result) {
+            console.error(`Node not found: ${args.id}`);
+            process.exit(1);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(result.node, null, 2));
+        }
+        else {
+            printNode(result.node, true);
+            if (result.outgoing.length > 0) {
+                console.log(`${pc.dim("Outgoing relationships")}:`);
+                for (const r of result.outgoing)
+                    console.log(`  → ${pc.dim(r.type)} → ${pc.cyan(r.to)}`);
+            }
+            if (result.incoming.length > 0) {
+                console.log(`${pc.dim("Incoming relationships")}:`);
+                for (const r of result.incoming)
+                    console.log(`  ← ${pc.dim(r.type)} ← ${pc.cyan(r.from)}`);
+            }
+        }
+    },
+};
+const relsSubcommand = {
+    name: "rels",
+    description: queryRelationshipsOp.def.description,
+    apiLink: queryRelationshipsOp.def.name,
+    args: relsArgs,
+    opts: relsOpts,
+    action(rawArgs, rawOpts) {
+        const args = relsArgs.parse(rawArgs);
+        const opts = relsOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const rels = queryRelationshipsOp({
+            doc,
+            from: opts.from,
+            to: opts.to,
+            type: opts.type,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(rels, null, 2));
+        }
+        else {
+            for (const r of rels) {
+                console.log(`${pc.cyan(r.from.padEnd(12))} ${pc.dim(r.type.padEnd(20))} ${pc.cyan(r.to)}`);
+            }
+            console.log(`\n${String(rels.length)} relationship(s)`);
+        }
+    },
+};
+const traceSubcommand = {
+    name: "trace",
+    description: traceFromNodeOp.def.description,
+    apiLink: traceFromNodeOp.def.name,
+    args: traceArgs,
+    opts: traceOpts,
+    action(rawArgs, rawOpts) {
+        const args = traceArgs.parse(rawArgs);
+        const opts = traceOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const trace = traceFromNodeOp({ doc, startId: args.id });
+        if (opts.json) {
+            console.log(JSON.stringify(trace, null, 2));
+        }
+        else if (isTraceTreeNode(trace)) {
+            printTraceTree(trace, 0);
+        }
+    },
+};
+const timelineSubcommand = {
+    name: "timeline",
+    description: timelineOp.def.description,
+    apiLink: timelineOp.def.name,
+    args: timelineArgs,
+    opts: timelineOpts,
+    action(rawArgs, rawOpts) {
+        const args = timelineArgs.parse(rawArgs);
+        const opts = timelineOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const events = opts.node
+            ? nodeHistoryOp({ doc, nodeId: opts.node })
+            : timelineOp({ doc });
+        if (opts.json) {
+            console.log(JSON.stringify(events, null, 2));
+        }
+        else {
+            if (events.length === 0) {
+                console.log("(no timestamped events)");
+            }
+            else {
+                for (const event of events) {
+                    console.log(`${event.timestamp}  ${event.nodeId} (${event.nodeType})  ${event.state}`);
+                }
+            }
+        }
+    },
+};
+const stateAtSubcommand = {
+    name: "state-at",
+    description: stateAtOp.def.description,
+    apiLink: stateAtOp.def.name,
+    args: stateAtArgs,
+    opts: stateAtOpts,
+    action(rawArgs, rawOpts) {
+        const args = stateAtArgs.parse(rawArgs);
+        const opts = stateAtOpts.parse(rawOpts);
+        const { doc } = loadDoc(args.input);
+        const result = stateAtOp({ doc, timestamp: args.time });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            if (result.length === 0) {
+                console.log(`(no active states at ${args.time})`);
+            }
+            else {
+                for (const nodeState of result) {
+                    console.log(`${nodeState.nodeId} (${nodeState.nodeName}): ${nodeState.activeStates.join(", ")}`);
+                }
+            }
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
+export const queryCommand = {
+    name: "query",
+    description: "Query nodes, relationships, traces, and temporal state",
+    subcommands: [
+        nodesSubcommand,
+        nodeSubcommand,
+        relsSubcommand,
+        traceSubcommand,
+        timelineSubcommand,
+        stateAtSubcommand,
+    ],
+};

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

@@ -0,0 +1,13 @@
+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<{
+    json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    sync: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const removeCommand: CommandDef<typeof argsSchema, typeof optsSchema>;
+export {};

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

@@ -0,0 +1,50 @@
+import * as z from "zod";
+import { removeNodeOp } from "../../operations/index.js";
+import { inputArg, mutationOpts, loadDoc, persistDoc } from "../shared.js";
+const argsSchema = z.object({
+    input: inputArg,
+    nodeId: z.string().describe("ID of the node to remove"),
+});
+const optsSchema = mutationOpts;
+export const removeCommand = {
+    name: "remove",
+    description: removeNodeOp.def.description,
+    apiLink: removeNodeOp.def.name,
+    args: argsSchema,
+    opts: optsSchema,
+    action(args, opts) {
+        const loaded = loadDoc(args.input);
+        const { doc } = loaded;
+        const targetId = args.nodeId;
+        const removedNode = doc.nodes.find((n) => n.id === targetId);
+        try {
+            const result = removeNodeOp({ doc, id: targetId });
+            // Count removed relationships
+            const before = (doc.relationships ?? []).length;
+            const after = (result.doc.relationships ?? []).length;
+            const removedRels = before - after;
+            persistDoc(result.doc, loaded, opts);
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    removed: removedNode,
+                    removedRelationships: removedRels,
+                    warnings: result.warnings,
+                }, null, 2));
+            }
+            else {
+                if (removedRels > 0) {
+                    console.log(`Removed ${String(removedRels)} relationship(s) involving ${targetId}`);
+                }
+                // Print warnings
+                for (const warning of result.warnings) {
+                    console.warn(`Warning: ${warning}`);
+                }
+                console.log(`${opts.dryRun ? "[dry-run] Would remove" : "Removed"} ${String(removedNode?.type)} ${targetId} — ${String(removedNode?.name)}`);
+            }
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+};

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

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

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

@@ -0,0 +1,34 @@
+import * as z from "zod";
+import { renameOp } from "../../operations/index.js";
+import { inputArg, mutationOpts, loadDoc, persistDoc } from "../shared.js";
+const argsSchema = z.object({
+    input: inputArg,
+    oldId: z.string().describe("Current node ID"),
+    newId: z.string().describe("New node ID"),
+});
+const optsSchema = mutationOpts;
+export const renameCommand = {
+    name: "rename",
+    description: renameOp.def.description,
+    apiLink: renameOp.def.name,
+    args: argsSchema,
+    opts: optsSchema,
+    action(args, opts) {
+        try {
+            const loaded = loadDoc(args.input);
+            const { doc } = loaded;
+            const updated = renameOp({ doc, oldId: args.oldId, newId: args.newId });
+            persistDoc(updated, loaded, opts);
+            if (opts.json) {
+                console.log(JSON.stringify({ oldId: args.oldId, newId: args.newId }, null, 2));
+            }
+            else {
+                console.log(`${opts.dryRun ? "[dry-run] Would rename" : "Renamed"} ${args.oldId} → ${args.newId}`);
+            }
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+};

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

@@ -0,0 +1,11 @@
+import * as z from "zod";
+import type { CommandDef } from "../define-command.js";
+declare const argsSchema: z.ZodObject<{
+    input: z.ZodString;
+    term: z.ZodString;
+}, z.core.$strip>;
+declare const optsSchema: z.ZodObject<{
+    json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const searchCommand: CommandDef<typeof argsSchema, typeof optsSchema>;
+export {};

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

@@ -0,0 +1,37 @@
+import * as z from "zod";
+import { searchOp } from "../../operations/index.js";
+import { inputArg, readOpts, loadDoc } from "../shared.js";
+import { textToString } from "../../text.js";
+const argsSchema = z.object({
+    input: inputArg,
+    term: z.string().describe("Search term"),
+});
+const optsSchema = readOpts;
+export const searchCommand = {
+    name: "search",
+    description: searchOp.def.description,
+    apiLink: searchOp.def.name,
+    args: argsSchema,
+    opts: optsSchema,
+    action(args, opts) {
+        const { doc } = loadDoc(args.input);
+        const matches = searchOp({ doc, term: args.term });
+        if (opts.json) {
+            console.log(JSON.stringify(matches, null, 2));
+        }
+        else {
+            if (matches.length === 0) {
+                console.log(`No matches for "${args.term}"`);
+            }
+            else {
+                for (const m of matches) {
+                    const desc = m.description
+                        ? " — " + textToString(m.description).slice(0, 60)
+                        : "";
+                    console.log(`${m.id.padEnd(12)} ${m.type.padEnd(16)} ${m.name}${desc}`);
+                }
+                console.log(`\n${String(matches.length)} match(es)`);
+            }
+        }
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { CommandDef } from "../define-command.js";
+export declare const speckitCommand: CommandDef;