sysprom 1.3.0 → 1.5.0

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

@@ -7,9 +7,9 @@ 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";
+        dir: "dir";
     }>>;
 }, z.core.$strict>;
 export declare const initCommand: CommandDef<typeof argsSchema, typeof optsSchema>;

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

@@ -147,13 +147,13 @@ const removeRelSubcommand = {
         const opts = removeRelOpts.parse(rawOpts);
         const loaded = loadDoc(opts.path);
         const { doc } = loaded;
-        const newDoc = removeRelationshipOp({
+        const result = removeRelationshipOp({
             doc,
             from: args.from,
             type: args.type,
             to: args.to,
         });
-        persistDoc(newDoc, loaded, opts);
+        persistDoc(result.doc, loaded, opts);
         if (opts.json) {
             console.log(JSON.stringify({ from: args.from, type: args.type, to: args.to }, null, 2));
         }

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

@@ -32,6 +32,7 @@ export { graphOp } from "./graph.js";
 export { renameOp } from "./rename.js";
 export { jsonToMarkdownOp } from "./json-to-markdown.js";
 export { markdownToJsonOp } from "./markdown-to-json.js";
+export { syncDocumentsOp, type BidirectionalSyncResult, type ConflictStrategy, } from "./sync.js";
 export { speckitImportOp } from "./speckit-import.js";
 export { speckitExportOp } from "./speckit-export.js";
 export { speckitSyncOp, type SyncResult } from "./speckit-sync.js";

package/dist/src/operations/index.js

@@ -38,6 +38,8 @@ export { renameOp } from "./rename.js";
 // Conversion operations
 export { jsonToMarkdownOp } from "./json-to-markdown.js";
 export { markdownToJsonOp } from "./markdown-to-json.js";
+// Synchronisation operations
+export { syncDocumentsOp, } from "./sync.js";
 // Spec-Kit interoperability operations
 export { speckitImportOp } from "./speckit-import.js";
 export { speckitExportOp } from "./speckit-export.js";

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

@@ -602,6 +602,9 @@ export declare const removeNodeOp: import("./define-operation.js").DefinedOperat
         };
     };
     id: z.ZodString;
+    hard: z.ZodOptional<z.ZodBoolean>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    repair: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

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

@@ -17,17 +17,71 @@ export const removeNodeOp = defineOperation({
     input: z.object({
         doc: SysProMDocument,
         id: z.string(),
+        hard: z.boolean().optional(),
+        recursive: z.boolean().optional(),
+        repair: z.boolean().optional(),
     }),
     output: RemoveResult,
-    fn({ doc, id }) {
+    fn({ doc, id, hard, recursive, repair }) {
         const nodeIdx = doc.nodes.findIndex((n) => n.id === id);
         if (nodeIdx === -1) {
             throw new Error(`Node not found: ${id}`);
         }
+        const nodeToRemove = doc.nodes[nodeIdx];
         const warnings = [];
-        // Remove the node
-        const newNodes = doc.nodes.filter((n) => n.id !== id);
-        // Clean up all references to the removed node
+        // Check recursive guard for hard delete
+        if (hard && nodeToRemove.subsystem) {
+            if (!recursive) {
+                throw new Error(`Cannot hard delete node ${id} with subsystem without --recursive flag`);
+            }
+        }
+        let newNodes;
+        let newRelationships = doc.relationships ?? [];
+        if (hard) {
+            // Hard delete: physically remove the node
+            newNodes = doc.nodes.filter((n) => n.id !== id);
+            // Handle must_follow chain repair if requested
+            if (repair) {
+                const incomingChains = newRelationships.filter((r) => r.to === id && r.type === "must_follow");
+                const outgoingChains = newRelationships.filter((r) => r.from === id && r.type === "must_follow");
+                // Remove all relationships involving the deleted node
+                newRelationships = newRelationships.filter((r) => r.from !== id && r.to !== id);
+                // Repair chains by connecting incoming to outgoing
+                // Only repair if there are both incoming AND outgoing chains
+                if (incomingChains.length > 0 && outgoingChains.length > 0) {
+                    for (const incoming of incomingChains) {
+                        for (const outgoing of outgoingChains) {
+                            // Only add if not already connected
+                            const exists = newRelationships.some((r) => r.from === incoming.from &&
+                                r.to === outgoing.to &&
+                                r.type === "must_follow");
+                            if (!exists) {
+                                newRelationships.push({
+                                    from: incoming.from,
+                                    to: outgoing.to,
+                                    type: "must_follow",
+                                });
+                                warnings.push(`Repaired chain: ${incoming.from} → ${outgoing.to}`);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // Without repair, just remove all relationships
+                const oldRelCount = newRelationships.length;
+                newRelationships = newRelationships.filter((r) => r.from !== id && r.to !== id);
+                if (newRelationships.length < oldRelCount) {
+                    warnings.push(`Removed relationships involving ${id}`);
+                }
+            }
+        }
+        else {
+            // Soft delete: mark as retired and preserve relationships
+            newNodes = doc.nodes.map((n) => n.id === id ? { ...n, status: "retired" } : n);
+            // Don't remove relationships in soft delete
+        }
+        // Clean up all references to the removed node (both soft and hard)
         const cleanedNodes = newNodes.map((n) => {
             let updated = n;
             // Remove from view includes
@@ -59,12 +113,6 @@ export const removeNodeOp = defineOperation({
             }
             return updated;
         });
-        // Remove relationships involving this node
-        const oldRelCount = (doc.relationships ?? []).length;
-        const newRelationships = (doc.relationships ?? []).filter((r) => r.from !== id && r.to !== id);
-        if (newRelationships.length < oldRelCount) {
-            warnings.push(`Removed relationships involving ${id}`);
-        }
         // Remove from external references
         const newExternalRefs = (doc.external_references ?? []).filter((ref) => ref.node_id !== id);
         return {