airgen-cli 0.8.0 → 0.10.0

package/dist/commands/diagrams.js

@@ -362,6 +362,50 @@ export function registerDiagramCommands(program, client) {
         await client.delete(`/architecture/diagrams/${tenant}/${project}/${id}`);
         console.log("Diagram deleted.");
     });
+    cmd
+        .command("deduplicate")
+        .description("Find and remove duplicate-named diagrams (keeps the one with more blocks)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("--dry-run", "Show duplicates without deleting")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/architecture/diagrams/${tenant}/${project}`);
+        const diagrams = data.diagrams ?? [];
+        // Group by name
+        const byName = new Map();
+        for (const d of diagrams) {
+            const name = (d.name ?? "").toLowerCase().trim();
+            const group = byName.get(name) ?? [];
+            group.push(d);
+            byName.set(name, group);
+        }
+        const duplicates = [...byName.entries()].filter(([, group]) => group.length > 1);
+        if (duplicates.length === 0) {
+            console.log("No duplicate diagrams found.");
+            return;
+        }
+        let removed = 0;
+        for (const [name, group] of duplicates) {
+            // Keep the one with the most blocks, or the newest
+            const sorted = group.sort((a, b) => (b.blockCount ?? 0) - (a.blockCount ?? 0) || (b.id > a.id ? 1 : -1));
+            const keep = sorted[0];
+            const toRemove = sorted.slice(1);
+            console.log(`"${keep.name ?? name}": keeping ${keep.id} (${keep.blockCount ?? 0} blocks), removing ${toRemove.length} duplicate(s)`);
+            if (!opts.dryRun) {
+                for (const dup of toRemove) {
+                    await client.delete(`/architecture/diagrams/${tenant}/${project}/${dup.id}`);
+                    removed++;
+                }
+            }
+            else {
+                for (const dup of toRemove) {
+                    console.log(`  [dry-run] would remove ${dup.id} (${dup.blockCount ?? 0} blocks)`);
+                }
+                removed += toRemove.length;
+            }
+        }
+        console.log(`${opts.dryRun ? "Would remove" : "Removed"} ${removed} duplicate diagram(s).`);
+    });
     // Blocks sub-group
     const blocks = cmd.command("blocks").description("Manage blocks in diagrams");
     blocks

package/dist/commands/documents.js

@@ -111,6 +111,70 @@ export function registerDocumentCommands(program, client) {
             output(data);
         }
     });
+    sections
+        .command("list")
+        .description("List sections in a document with requirement counts")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<document>", "Document slug")
+        .action(async (tenant, project, document) => {
+        const data = await client.get(`/sections/${tenant}/${project}/${document}/full`);
+        const secs = data.sections ?? [];
+        if (isJsonMode()) {
+            output(secs);
+        }
+        else {
+            if (secs.length === 0) {
+                console.log("No sections found.");
+                return;
+            }
+            printTable(["ID", "Name", "Code", "Order", "Reqs"], secs.map(s => [
+                s.id,
+                s.name,
+                s.shortCode ?? "",
+                String(s.order ?? 0),
+                String(s.requirements?.length ?? 0),
+            ]));
+        }
+    });
+    sections
+        .command("merge")
+        .description("Move all requirements from source section to target, then delete source")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<from-section-id>", "Source section ID")
+        .argument("<to-section-id>", "Target section ID")
+        .option("--dry-run", "Show what would be moved without executing")
+        .action(async (tenant, project, fromId, toId, opts) => {
+        // Get requirements in source section
+        const secData = await client.get(`/sections/${fromId}/requirements`);
+        const reqs = secData.requirements ?? [];
+        if (reqs.length === 0) {
+            console.log("Source section has no requirements.");
+            if (!opts.dryRun) {
+                await client.delete(`/sections/${fromId}`, { tenant });
+                console.log("Empty section deleted.");
+            }
+            return;
+        }
+        console.log(`Moving ${reqs.length} requirement(s) from ${fromId} to ${toId}...`);
+        if (opts.dryRun) {
+            for (const r of reqs) {
+                console.log(`  [dry-run] ${r.ref}: would move to ${toId}`);
+            }
+            console.log(`[dry-run] Would delete source section ${fromId}`);
+            return;
+        }
+        // Move each requirement to the target section
+        let moved = 0;
+        for (const r of reqs) {
+            await client.patch(`/requirements/${tenant}/${project}/${r.id}`, { sectionId: toId });
+            moved++;
+        }
+        // Delete the now-empty source section
+        await client.delete(`/sections/${fromId}`, { tenant });
+        console.log(`Merged ${moved} requirement(s) and deleted source section.`);
+    });
     sections
         .command("delete")
         .description("Delete a section")

package/dist/commands/projects.js

@@ -47,6 +47,113 @@ export function registerProjectCommands(program, client) {
             output(data);
         }
     });
+    cmd
+        .command("scaffold")
+        .description("Create a project with standard SE document structure, sections, and linksets")
+        .argument("<tenant>", "Tenant slug")
+        .requiredOption("--name <name>", "System name (e.g. 'Autonomous Vehicle')")
+        .option("--key <key>", "Project key (auto-generated from name)")
+        .option("--template <tpl>", "Template: se (default), safety", "se")
+        .action(async (tenant, opts) => {
+        const slug = opts.key ?? `se-${opts.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "")}`;
+        const seDocuments = [
+            { name: "Stakeholder Needs", code: "STK-NEEDS", sections: [
+                    { name: "Operational Needs", code: "OPS" },
+                    { name: "Performance Needs", code: "PERF" },
+                    { name: "Constraints", code: "CON" },
+                ] },
+            { name: "System Requirements", code: "SYS-REQS", sections: [
+                    { name: "Functional Requirements", code: "FUNC" },
+                    { name: "Performance Requirements", code: "PERF" },
+                    { name: "Interface Requirements", code: "IFC" },
+                    { name: "Environmental Requirements", code: "ENV" },
+                ] },
+            { name: "Subsystem Requirements", code: "SUB-REQS", sections: [
+                    { name: "Subsystem Functional", code: "FUNC" },
+                    { name: "Subsystem Performance", code: "PERF" },
+                    { name: "Subsystem Interface", code: "IFC" },
+                ] },
+            { name: "Architecture Description", code: "ARC", sections: [
+                    { name: "System Architecture", code: "SYS-ARC" },
+                    { name: "Subsystem Allocation", code: "ALLOC" },
+                    { name: "Interface Definitions", code: "IFC-DEF" },
+                ] },
+            { name: "Verification Plan", code: "VER", sections: [
+                    { name: "Test Cases", code: "TEST" },
+                    { name: "Analysis Cases", code: "ANAL" },
+                    { name: "Inspection Cases", code: "INSP" },
+                ] },
+            { name: "Traceability Matrix", code: "TRC", sections: [
+                    { name: "Coverage Summary", code: "COV" },
+                ] },
+        ];
+        const seLinksets = [
+            { source: "stakeholder-needs", target: "system-requirements" },
+            { source: "system-requirements", target: "subsystem-requirements" },
+            { source: "architecture-description", target: "subsystem-requirements" },
+            { source: "system-requirements", target: "verification-plan" },
+            { source: "subsystem-requirements", target: "verification-plan" },
+        ];
+        const safetyExtras = [
+            { name: "Hazard Analysis", code: "HAZ", sections: [
+                    { name: "Hazard Identification", code: "HZID" },
+                    { name: "Risk Assessment", code: "RISK" },
+                    { name: "Safety Requirements", code: "SAFE" },
+                ] },
+        ];
+        const documents = [...seDocuments];
+        const linksets = [...seLinksets];
+        if (opts.template === "safety") {
+            documents.push(...safetyExtras);
+            linksets.push({ source: "hazard-analysis", target: "system-requirements" }, { source: "hazard-analysis", target: "verification-plan" });
+        }
+        console.error(`Scaffolding project "${opts.name}" (${slug})...`);
+        // 1. Create project
+        console.error("  Creating project...");
+        await client.post(`/tenants/${tenant}/projects`, {
+            slug,
+            name: opts.name,
+            key: opts.key,
+        });
+        // 2. Create documents and sections
+        const docSlugs = new Map();
+        for (const doc of documents) {
+            console.error(`  Creating document: ${doc.name}...`);
+            const docData = await client.post("/documents", {
+                tenant,
+                projectKey: slug,
+                name: doc.name,
+                shortCode: doc.code,
+            });
+            const docSlug = docData.document.slug;
+            docSlugs.set(doc.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""), docSlug);
+            for (let i = 0; i < doc.sections.length; i++) {
+                const sec = doc.sections[i];
+                await client.post("/sections", {
+                    tenant,
+                    projectKey: slug,
+                    documentSlug: docSlug,
+                    name: sec.name,
+                    shortCode: sec.code,
+                    order: i,
+                });
+            }
+        }
+        // 3. Create linksets
+        for (const ls of linksets) {
+            const srcSlug = docSlugs.get(ls.source);
+            const tgtSlug = docSlugs.get(ls.target);
+            if (srcSlug && tgtSlug) {
+                console.error(`  Creating linkset: ${ls.source} → ${ls.target}...`);
+                await client.post(`/linksets/${tenant}/${slug}`, {
+                    sourceDocumentSlug: srcSlug,
+                    targetDocumentSlug: tgtSlug,
+                });
+            }
+        }
+        const totalSections = documents.reduce((sum, d) => sum + d.sections.length, 0);
+        console.log(`Project scaffolded: ${documents.length} documents, ${totalSections} sections, ${linksets.length} linksets.`);
+    });
     cmd
         .command("delete")
         .description("Delete a project")

package/dist/commands/traceability.js

@@ -34,7 +34,7 @@ export function registerTraceabilityCommands(program, client) {
         .argument("<project-key>", "Project key")
         .requiredOption("--source <id>", "Source requirement ID")
         .requiredOption("--target <id>", "Target requirement ID")
-        .requiredOption("--type <type>", "Link type: satisfies, derives, verifies, implements, refines, conflicts")
+        .requiredOption("--type <type>", "Link type: satisfies, derives, verifies, implements, refines, conflicts, motivates")
         .option("--description <desc>", "Short description for traceability matrices")
         .option("--rationale <text>", "Engineering justification for why this link exists")
         .action(async (tenant, projectKey, opts) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airgen-cli",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "AIRGen CLI — requirements engineering from the command line",
   "type": "module",
   "main": "dist/index.js",