sysprom 1.0.7 → 1.2.0

package/dist/src/operations/define-operation.d.ts

@@ -1,14 +1,45 @@
 import * as z from "zod";
+/**
+ * Definition of a SysProM operation — a named, typed function with Zod schemas
+ * for input validation and output description.
+ *
+ * @typeParam TInput - Zod schema type for the operation's input.
+ * @typeParam TOutput - Zod schema type for the operation's output.
+ */
 export interface OperationDef<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> {
+    /** Machine-readable operation name (e.g. `"addNode"`). */
     name: string;
+    /** Human-readable description of what the operation does. */
     description: string;
+    /** Zod schema used to validate the operation's input. */
     input: TInput;
+    /** Zod schema describing the operation's output shape. */
     output: TOutput;
+    /** The implementation function. */
     fn: (input: z.infer<TInput>) => z.infer<TOutput>;
 }
+/**
+ * A callable operation with attached metadata. Can be invoked directly as a
+ * function, and also exposes `.def`, `.inputSchema`, and `.outputSchema` for
+ * introspection.
+ *
+ * @typeParam TInput - Zod schema type for the operation's input.
+ * @typeParam TOutput - Zod schema type for the operation's output.
+ */
 export type DefinedOperation<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> = ((input: z.infer<TInput>) => z.infer<TOutput>) & {
+    /** The full operation definition including name, description, and schemas. */
     def: OperationDef<TInput, TOutput>;
+    /** Zod schema for validating input before execution. */
     inputSchema: TInput;
+    /** Zod schema describing the output shape. */
     outputSchema: TOutput;
 };
+/**
+ * Create a callable operation from a definition. The returned function validates
+ * input against the Zod schema before delegating to the implementation.
+ *
+ * @param def - The operation definition with name, schemas, and implementation.
+ * @returns A callable function with `.def`, `.inputSchema`, and `.outputSchema` attached.
+ * @throws If the input fails Zod validation.
+ */
 export declare function defineOperation<TInput extends z.ZodType, TOutput extends z.ZodType>(def: OperationDef<TInput, TOutput>): DefinedOperation<TInput, TOutput>;

package/dist/src/operations/define-operation.js

@@ -1,6 +1,14 @@
 // ---------------------------------------------------------------------------
 // defineOperation — creates a callable operation with attached metadata
 // ---------------------------------------------------------------------------
+/**
+ * Create a callable operation from a definition. The returned function validates
+ * input against the Zod schema before delegating to the implementation.
+ *
+ * @param def - The operation definition with name, schemas, and implementation.
+ * @returns A callable function with `.def`, `.inputSchema`, and `.outputSchema` attached.
+ * @throws If the input fails Zod validation.
+ */
 export function defineOperation(def) {
     function execute(input) {
         const parsed = def.input.safeParse(input);

package/dist/src/operations/graph.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering by relationship type. */
 export declare const graphOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/graph.js

@@ -56,6 +56,7 @@ function generateGraph(doc, format, typeFilter) {
     }
     return generateMermaid(doc, rels);
 }
+/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering by relationship type. */
 export const graphOp = defineOperation({
     name: "graph",
     description: "Generate a graph of the SysProM document in Mermaid or DOT format, with optional filtering by relationship type.",

package/dist/src/operations/init-document.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Create a new empty SysProM document with metadata, ready for nodes and relationships to be added. */
 export declare const initDocumentOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     scope: z.ZodDefault<z.ZodOptional<z.ZodString>>;

package/dist/src/operations/init-document.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
+/** Create a new empty SysProM document with metadata, ready for nodes and relationships to be added. */
 export const initDocumentOp = defineOperation({
     name: "initDocument",
     description: "Create a new empty SysProM document with metadata.",

package/dist/src/operations/json-to-markdown.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Convert a SysProM document to single-file Markdown representation. */
 export declare const jsonToMarkdownOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/json-to-markdown.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { jsonToMarkdownSingle } from "../json-to-md.js";
+/** Convert a SysProM document to single-file Markdown representation. */
 export const jsonToMarkdownOp = defineOperation({
     name: "jsonToMarkdown",
     description: "Convert a SysProM document to single-file Markdown",

package/dist/src/operations/mark-task-done.d.ts

@@ -1,4 +1,9 @@
 import * as z from "zod";
+/**
+ * Mark a task as done within a change node's plan.
+ *
+ * @throws If the change node is not found or the task index is out of range.
+ */
 export declare const markTaskDoneOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/mark-task-done.js

@@ -1,6 +1,11 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
+/**
+ * Mark a task as done within a change node's plan.
+ *
+ * @throws If the change node is not found or the task index is out of range.
+ */
 export const markTaskDoneOp = defineOperation({
     name: "markTaskDone",
     description: "Mark a task as done",

package/dist/src/operations/mark-task-undone.d.ts

@@ -1,4 +1,9 @@
 import * as z from "zod";
+/**
+ * Mark a task as undone (incomplete) within a change node's plan.
+ *
+ * @throws If the change node is not found or the task index is out of range.
+ */
 export declare const markTaskUndoneOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/mark-task-undone.js

@@ -1,6 +1,11 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
+/**
+ * Mark a task as undone (incomplete) within a change node's plan.
+ *
+ * @throws If the change node is not found or the task index is out of range.
+ */
 export const markTaskUndoneOp = defineOperation({
     name: "markTaskUndone",
     description: "Mark a task as undone",

package/dist/src/operations/markdown-to-json.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Parse single-file Markdown content into a SysProM document. */
 export declare const markdownToJsonOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     content: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{

package/dist/src/operations/markdown-to-json.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { markdownSingleToJson } from "../md-to-json.js";
+/** Parse single-file Markdown content into a SysProM document. */
 export const markdownToJsonOp = defineOperation({
     name: "markdownToJson",
     description: "Parse Markdown content into a SysProM document",

package/dist/src/operations/next-id.d.ts

@@ -1,4 +1,10 @@
 import * as z from "zod";
+/**
+ * Generate the next available ID for a given node type. Scans existing node IDs
+ * matching the type's conventional prefix and returns `prefix + (max + 1)`.
+ *
+ * @throws If no ID prefix is defined for the given node type.
+ */
 export declare const nextIdOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/next-id.js

@@ -1,6 +1,12 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument, NodeType, NODE_ID_PREFIX } from "../schema.js";
+/**
+ * Generate the next available ID for a given node type. Scans existing node IDs
+ * matching the type's conventional prefix and returns `prefix + (max + 1)`.
+ *
+ * @throws If no ID prefix is defined for the given node type.
+ */
 export const nextIdOp = defineOperation({
     name: "nextId",
     description: "Generate the next available ID for a given node type. Scans existing node IDs matching the type's prefix and returns prefix + (max + 1).",

package/dist/src/operations/node-history.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Zod schema for a timestamped lifecycle event of a specific node. */
 export declare const TimelineEvent: z.ZodObject<{
     nodeId: z.ZodString;
     nodeName: z.ZodString;
@@ -6,7 +7,9 @@ export declare const TimelineEvent: z.ZodObject<{
     state: z.ZodString;
     timestamp: z.ZodString;
 }, z.core.$strip>;
+/** A timestamped lifecycle event of a specific node. */
 export type TimelineEvent = z.infer<typeof TimelineEvent>;
+/** Extract the lifecycle history of a specific node, sorted chronologically. Searches recursively into subsystems. Returns an empty array if the node is not found. */
 export declare const nodeHistoryOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/node-history.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
+/** Zod schema for a timestamped lifecycle event of a specific node. */
 export const TimelineEvent = z.object({
     nodeId: z.string(),
     nodeName: z.string(),
@@ -8,6 +9,7 @@ export const TimelineEvent = z.object({
     state: z.string(),
     timestamp: z.string(),
 });
+/** Extract the lifecycle history of a specific node, sorted chronologically. Searches recursively into subsystems. Returns an empty array if the node is not found. */
 export const nodeHistoryOp = defineOperation({
     name: "node-history",
     description: "Extract the lifecycle history of a specific node, sorted chronologically",

package/dist/src/operations/plan-add-task.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Add a task (change node) to a plan's implementation protocol. Optionally specify a parent task for nesting. */
 export declare const planAddTaskOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/plan-add-task.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { addTask } from "../speckit/plan.js";
+/** Add a task (change node) to a plan's implementation protocol. Optionally specify a parent task for nesting. */
 export const planAddTaskOp = defineOperation({
     name: "planAddTask",
     description: "Add a task (change node) to a plan's implementation protocol",

package/dist/src/operations/plan-gate.d.ts

@@ -13,7 +13,9 @@ export declare const GateIssueSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"fr_no_change">;
     frId: z.ZodString;
 }, z.core.$strip>]>;
+/** A specific issue preventing gate entry — incomplete tasks, missing acceptance criteria, or unlinked requirements. */
 export type GateIssueResult = z.infer<typeof GateIssueSchema>;
+/** Zod schema for the gate check result — phase number, readiness flag, and issues. */
 export declare const GateResultSchema: z.ZodObject<{
     phase: z.ZodNumber;
     ready: z.ZodBoolean;
@@ -32,7 +34,9 @@ export declare const GateResultSchema: z.ZodObject<{
         frId: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strip>;
+/** Result of a gate check: phase number, readiness flag, and any blocking issues. */
 export type GateResultOutput = z.infer<typeof GateResultSchema>;
+/** Check gate criteria for phase entry — validates that previous tasks are complete and requirements are linked. */
 export declare const planGateOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/plan-gate.js

@@ -21,11 +21,13 @@ export const GateIssueSchema = z.union([
         frId: z.string(),
     }),
 ]);
+/** Zod schema for the gate check result — phase number, readiness flag, and issues. */
 export const GateResultSchema = z.object({
     phase: z.number(),
     ready: z.boolean(),
     issues: z.array(GateIssueSchema),
 });
+/** Check gate criteria for phase entry — validates that previous tasks are complete and requirements are linked. */
 export const planGateOp = defineOperation({
     name: "planGate",
     description: "Check gate criteria for phase entry",

package/dist/src/operations/plan-init.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Initialise a new SysProM plan document with standard structure (constitution, specification, implementation protocol, checklist). */
 export declare const planInitOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     prefix: z.ZodString;
     name: z.ZodOptional<z.ZodString>;

package/dist/src/operations/plan-init.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { initDocument } from "../speckit/plan.js";
+/** Initialise a new SysProM plan document with standard structure (constitution, specification, implementation protocol, checklist). */
 export const planInitOp = defineOperation({
     name: "planInit",
     description: "Initialise a new SysProM plan document with standard structure",

package/dist/src/operations/plan-progress.d.ts

@@ -6,7 +6,9 @@ export declare const PhaseProgressSchema: z.ZodObject<{
     total: z.ZodNumber;
     percent: z.ZodNumber;
 }, z.core.$strip>;
+/** Per-phase progress metrics: task counts and completion percentage. */
 export type PhaseProgressResult = z.infer<typeof PhaseProgressSchema>;
+/** Compute per-phase progress breakdown for a plan — task completion counts and percentages for each phase. */
 export declare const planProgressOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/plan-progress.js

@@ -9,6 +9,7 @@ export const PhaseProgressSchema = z.object({
     total: z.number(),
     percent: z.number(),
 });
+/** Compute per-phase progress breakdown for a plan — task completion counts and percentages for each phase. */
 export const planProgressOp = defineOperation({
     name: "planProgress",
     description: "Get per-phase progress breakdown",

package/dist/src/operations/plan-status.d.ts

@@ -24,7 +24,9 @@ export declare const PlanStatusSchema: z.ZodObject<{
     }, z.core.$strip>;
     nextStep: z.ZodString;
 }, z.core.$strip>;
+/** Comprehensive status of all plan components — constitution, spec, plan, tasks, checklist, and next step. */
 export type PlanStatusResult = z.infer<typeof PlanStatusSchema>;
+/** Get the comprehensive status of all plan components in a single operation. */
 export declare const planStatusOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/plan-status.js

@@ -27,6 +27,7 @@ export const PlanStatusSchema = z.object({
     }),
     nextStep: z.string(),
 });
+/** Get the comprehensive status of all plan components in a single operation. */
 export const planStatusOp = defineOperation({
     name: "planStatus",
     description: "Get the status of all plan components",

package/dist/src/operations/query-node.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Zod schema for a node with its incoming and outgoing relationships, or null if not found. */
 export declare const NodeDetail: z.ZodNullable<z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodString;
@@ -382,7 +383,9 @@ export declare const NodeDetail: z.ZodNullable<z.ZodObject<{
         };
     }>;
 }, z.core.$strip>>;
+/** A node with its incoming and outgoing relationships, or null if the node was not found. */
 export type NodeDetail = z.infer<typeof NodeDetail>;
+/** Query a single node by ID, returning it with its incoming and outgoing relationships. Returns null if the node does not exist. */
 export declare const queryNodeOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/query-node.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { Node, Relationship, SysProMDocument } from "../schema.js";
+/** Zod schema for a node with its incoming and outgoing relationships, or null if not found. */
 export const NodeDetail = z
     .object({
     node: Node,
@@ -8,6 +9,7 @@ export const NodeDetail = z
     incoming: z.array(Relationship),
 })
     .nullable();
+/** Query a single node by ID, returning it with its incoming and outgoing relationships. Returns null if the node does not exist. */
 export const queryNodeOp = defineOperation({
     name: "query-node",
     description: "Query a single node by ID with its incoming and outgoing relationships",

package/dist/src/operations/query-nodes.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Query nodes from a SysProM document with optional filters for type and status. */
 export declare const queryNodesOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/query-nodes.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { Node, SysProMDocument } from "../schema.js";
+/** Query nodes from a SysProM document with optional filters for type and status. */
 export const queryNodesOp = defineOperation({
     name: "query-nodes",
     description: "Query nodes with optional filters for type and status",

package/dist/src/operations/query-relationships.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Query relationships from a SysProM document with optional filters for from, to, and type. */
 export declare const queryRelationshipsOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/query-relationships.js

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { Relationship, SysProMDocument } from "../schema.js";
+/** Query relationships from a SysProM document with optional filters for from, to, and type. */
 export const queryRelationshipsOp = defineOperation({
     name: "query-relationships",
     description: "Query relationships with optional filters for from, to, and type",

package/dist/src/operations/remove-node.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Zod schema for the result of removing a node — the updated document plus any warnings. */
 export declare const RemoveResult: z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;
@@ -297,7 +298,14 @@ export declare const RemoveResult: z.ZodObject<{
     };
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+/** Result of removing a node: the updated document and any warnings about lingering references. */
 export type RemoveResult = z.infer<typeof RemoveResult>;
+/**
+ * Remove a node and all relationships involving it. Also removes the node from
+ * view includes and external references. Warns if scope or operation references remain.
+ *
+ * @throws If the node ID is not found.
+ */
 export declare const removeNodeOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/remove-node.js

@@ -1,10 +1,17 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
+/** Zod schema for the result of removing a node — the updated document plus any warnings. */
 export const RemoveResult = z.object({
     doc: SysProMDocument,
     warnings: z.array(z.string()),
 });
+/**
+ * Remove a node and all relationships involving it. Also removes the node from
+ * view includes and external references. Warns if scope or operation references remain.
+ *
+ * @throws If the node ID is not found.
+ */
 export const removeNodeOp = defineOperation({
     name: "removeNode",
     description: "Remove a node and all relationships involving it. Also removes the node from view includes and external references.",

package/dist/src/operations/remove-relationship.d.ts

@@ -1,4 +1,9 @@
 import * as z from "zod";
+/**
+ * Remove a relationship matching from, type, and to. Returns a new document without it.
+ *
+ * @throws If no matching relationship is found.
+ */
 export declare const removeRelationshipOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/remove-relationship.js

@@ -1,6 +1,11 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument, RelationshipType } from "../schema.js";
+/**
+ * Remove a relationship matching from, type, and to. Returns a new document without it.
+ *
+ * @throws If no matching relationship is found.
+ */
 export const removeRelationshipOp = defineOperation({
     name: "removeRelationship",
     description: "Remove a relationship matching from, type, and to. Throws if the relationship is not found.",

package/dist/src/operations/rename.d.ts

@@ -1,4 +1,11 @@
 import * as z from "zod";
+/**
+ * Rename a node ID across all references in the document — the node itself,
+ * relationships, scope, includes, operation targets, external references, and
+ * recursively into subsystems.
+ *
+ * @throws If the old ID is not found or the new ID already exists.
+ */
 export declare const renameOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/rename.js

@@ -89,6 +89,13 @@ function renameNodeId(doc, oldId, newId) {
         external_references: external_references.length > 0 ? external_references : undefined,
     };
 }
+/**
+ * Rename a node ID across all references in the document — the node itself,
+ * relationships, scope, includes, operation targets, external references, and
+ * recursively into subsystems.
+ *
+ * @throws If the old ID is not found or the new ID already exists.
+ */
 export const renameOp = defineOperation({
     name: "rename",
     description: "Rename a node ID across all references in the document. Updates the node's own ID, relationships, scope, includes, operations targets, external references, and recursively into subsystems.",

package/dist/src/operations/search.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Search for nodes by text (case-insensitive) across id, name, description, context, and rationale fields. Recursively searches into subsystems. */
 export declare const searchOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/search.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument, Node } from "../schema.js";
 import { textToString } from "../text.js";
+/** Search for nodes by text (case-insensitive) across id, name, description, context, and rationale fields. Recursively searches into subsystems. */
 export const searchOp = defineOperation({
     name: "search",
     description: "Search for nodes in a SysProM document by text across id, name, description, context, and rationale fields. Recursively searches into subsystems.",

package/dist/src/operations/speckit-diff.d.ts

@@ -1,5 +1,7 @@
 import * as z from "zod";
+/** Concise difference result — added, modified, and removed nodes with their IDs and names. */
 export type DiffResult = z.infer<typeof DiffResult>;
+/** Zod schema for the diff result. */
 export declare const DiffResult: z.ZodObject<{
     added: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -15,6 +17,7 @@ export declare const DiffResult: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/** Show differences between a SysProM document and a Spec-Kit directory — added, modified, and removed nodes. */
 export declare const speckitDiffOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/speckit-diff.js

@@ -28,6 +28,7 @@ function compareDocuments(oldDoc, newDoc) {
     }
     return { added, modified, removed };
 }
+/** Zod schema for the diff result. */
 export const DiffResult = z.object({
     added: z.array(z.object({
         id: z.string(),
@@ -43,6 +44,7 @@ export const DiffResult = z.object({
         name: z.string(),
     })),
 });
+/** Show differences between a SysProM document and a Spec-Kit directory — added, modified, and removed nodes. */
 export const speckitDiffOp = defineOperation({
     name: "speckitDiff",
     description: "Show differences between a SysProM document and a Spec-Kit directory",

package/dist/src/operations/speckit-export.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Export a SysProM document to Spec-Kit format, writing specification files to the output directory. Only nodes matching the given ID prefix are exported. */
 export declare const speckitExportOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/speckit-export.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { generateSpecKitProject } from "../speckit/generate.js";
+/** Export a SysProM document to Spec-Kit format, writing specification files to the output directory. Only nodes matching the given ID prefix are exported. */
 export const speckitExportOp = defineOperation({
     name: "speckitExport",
     description: "Export a SysProM document to Spec-Kit format",

package/dist/src/operations/speckit-import.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+/** Import a Spec-Kit feature directory into a SysProM document. Automatically detects the project's constitution file by searching parent directories. */
 export declare const speckitImportOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     speckitDir: z.ZodString;
     prefix: z.ZodOptional<z.ZodString>;

package/dist/src/operations/speckit-import.js

@@ -4,6 +4,7 @@ import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
 import { parseSpecKitFeature } from "../speckit/parse.js";
 import { detectSpecKitProject } from "../speckit/project.js";
+/** Import a Spec-Kit feature directory into a SysProM document. Automatically detects the project's constitution file by searching parent directories. */
 export const speckitImportOp = defineOperation({
     name: "speckitImport",
     description: "Import a Spec-Kit feature directory into a SysProM document",

package/dist/src/operations/speckit-sync.d.ts

@@ -1,5 +1,7 @@
 import * as z from "zod";
+/** Result of synchronising a SysProM document with a Spec-Kit directory — the merged document and change counts. */
 export type SyncResult = z.infer<typeof SyncResult>;
+/** Zod schema for the sync result. */
 export declare const SyncResult: z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;
@@ -300,6 +302,7 @@ export declare const SyncResult: z.ZodObject<{
     modified: z.ZodNumber;
     removed: z.ZodNumber;
 }, z.core.$strip>;
+/** Synchronise a SysProM document with a Spec-Kit directory. Spec-Kit content wins for descriptions and status; SysProM structure (relationships, hierarchies) is preserved. Regenerates the Spec-Kit directory from the merged document. */
 export declare const speckitSyncOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/speckit-sync.js

@@ -29,12 +29,14 @@ function compareDocuments(oldDoc, newDoc) {
     }
     return { added, modified, removed };
 }
+/** Zod schema for the sync result. */
 export const SyncResult = z.object({
     doc: SysProMDocument,
     added: z.number(),
     modified: z.number(),
     removed: z.number(),
 });
+/** Synchronise a SysProM document with a Spec-Kit directory. Spec-Kit content wins for descriptions and status; SysProM structure (relationships, hierarchies) is preserved. Regenerates the Spec-Kit directory from the merged document. */
 export const speckitSyncOp = defineOperation({
     name: "speckitSync",
     description: "Synchronise a SysProM document with a Spec-Kit directory",