airgen-cli 0.6.0 → 0.8.0

package/dist/commands/diagrams.js

@@ -32,23 +32,12 @@ function mermaidNodeShape(block) {
 }
 function mermaidArrow(kind) {
     switch (kind) {
-        case "flow": return "==>";
+        case "flow": return "-->";
         case "dependency": return "-.->";
         case "composition": return "-->";
         default: return "-->";
     }
 }
-function mermaidStyle(block) {
-    const id = sanitizeId(block.id);
-    switch (block.kind) {
-        case "system": return `style ${id} fill:#ebf8ff,stroke:#1a365d,color:#1a365d`;
-        case "subsystem": return `style ${id} fill:#f0f5ff,stroke:#2c5282,color:#2c5282`;
-        case "actor": return `style ${id} fill:#f0fff4,stroke:#276749,color:#276749`;
-        case "external": return `style ${id} fill:#fffbeb,stroke:#92400e,color:#92400e`;
-        case "interface": return `style ${id} fill:#faf5ff,stroke:#6b21a8,color:#6b21a8`;
-        default: return null;
-    }
-}
 // ── Terminal (layered) rendering ─────────────────────────────
 const KIND_ICONS = {
     system: "■", subsystem: "□", component: "◦",
@@ -205,12 +194,27 @@ function renderMermaid(blocks, connectors, direction) {
             lines.push(`  ${src} ${arrow} ${tgt}`);
         }
     }
-    // Styles
-    const styles = blocks.map(mermaidStyle).filter(Boolean);
-    if (styles.length > 0) {
+    // Class definitions for block kinds (more robust than per-node style lines)
+    const kindsUsed = new Set(blocks.map(b => b.kind).filter(Boolean));
+    const classDefs = {
+        system: "fill:#ebf8ff,stroke:#1a365d,color:#1a365d",
+        subsystem: "fill:#f0f5ff,stroke:#2c5282,color:#2c5282",
+        actor: "fill:#f0fff4,stroke:#276749,color:#276749",
+        external: "fill:#fffbeb,stroke:#92400e,color:#92400e",
+        interface: "fill:#faf5ff,stroke:#6b21a8,color:#6b21a8",
+    };
+    const classLines = [];
+    for (const kind of kindsUsed) {
+        if (kind && classDefs[kind]) {
+            classLines.push(`  classDef ${kind} ${classDefs[kind]}`);
+            const members = blocks.filter(b => b.kind === kind).map(b => sanitizeId(b.id));
+            classLines.push(`  class ${members.join(",")} ${kind}`);
+        }
+    }
+    if (classLines.length > 0) {
         lines.push("");
-        for (const s of styles)
-            lines.push(`  ${s}`);
+        for (const cl of classLines)
+            lines.push(cl);
     }
     return lines.join("\n");
 }

package/dist/commands/lint.js

@@ -154,14 +154,17 @@ function analyzeFindings(concepts, comparisons, requirements) {
     }
     // 4. Degraded mode gaps: requirements mentioning "manual", "reversion", "fallback" without performance criteria
     const degradedReqs = requirements.filter(r => r.text && /manual\s+(?:reversion|mode|override|backup)|fallback|degraded/i.test(r.text));
+    // Numeric performance patterns: "10 Hz", "3.6m", "250 ms", "95%", "< 5 seconds", ">= 99.9%",
+    // "within 100ms", "at least 10", units with numbers, ranges like "5-10"
+    const perfPattern = /\d+\.?\d*\s*(?:%|Hz|kHz|MHz|s\b|ms\b|sec|second|minute|min\b|hour|hr|m\b|km|cm|mm|m\/s|km\/h|mph|kph|dB|dBm|°C|°F|K\b|V\b|A\b|W\b|kW|MW|N\b|kN|Pa|kPa|MPa|bar|psi|kg|g\b|lb|fps|bps|Mbps|Gbps)|(?:within|under|below|above|at least|no (?:more|less) than|maximum|minimum)\s+\d|\d+\s*(?:to|-)\s*\d/i;
     for (const req of degradedReqs) {
-        const hasPerf = /\d+%|\d+\s*(?:second|ms|metre|meter|m\b)/i.test(req.text ?? "");
+        const hasPerf = perfPattern.test(req.text ?? "");
         if (!hasPerf) {
             findings.push({
                 severity: "medium",
                 category: "Coverage Gap",
                 title: `Degraded mode without performance criteria: ${req.ref}`,
-                description: `${req.ref} specifies a degraded/manual mode but provides no acceptance criteria for performance in that mode.`,
+                description: `${req.ref} specifies a degraded/manual mode but provides no measurable acceptance criteria for performance in that mode.`,
                 affectedReqs: [req.ref],
                 recommendation: "Add measurable performance criteria for degraded operation (e.g., acceptable accuracy, response time, available subsystems).",
             });

package/dist/commands/requirements.js

@@ -87,6 +87,7 @@ export function registerRequirementCommands(program, client) {
         .option("--document <slug>", "Document slug")
         .option("--section <id>", "Section ID")
         .option("--tags <tags>", "Comma-separated tags")
+        .option("--idempotency-key <key>", "Prevent duplicates on retry — returns existing if key was already used")
         .action(async (tenant, projectKey, opts) => {
         const data = await client.post("/requirements", {
             tenant,
@@ -99,12 +100,18 @@ export function registerRequirementCommands(program, client) {
             documentSlug: opts.document,
             sectionId: opts.section,
             tags: opts.tags?.split(",").map(t => t.trim()),
+            idempotencyKey: opts.idempotencyKey,
         });
         if (isJsonMode()) {
             output(data);
         }
         else {
-            console.log("Requirement created.");
+            if (data.deduplicated) {
+                console.log("Requirement already exists (idempotency key matched).");
+            }
+            else {
+                console.log("Requirement created.");
+            }
             output(data);
         }
     });

package/dist/commands/traceability.js

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { output, printTable, isJsonMode } from "../output.js";
 export function registerTraceabilityCommands(program, client) {
     const cmd = program.command("traces").alias("trace").description("Traceability links");
@@ -34,7 +35,8 @@ export function registerTraceabilityCommands(program, client) {
         .requiredOption("--source <id>", "Source requirement ID")
         .requiredOption("--target <id>", "Target requirement ID")
         .requiredOption("--type <type>", "Link type: satisfies, derives, verifies, implements, refines, conflicts")
-        .option("--description <desc>", "Description")
+        .option("--description <desc>", "Short description for traceability matrices")
+        .option("--rationale <text>", "Engineering justification for why this link exists")
         .action(async (tenant, projectKey, opts) => {
         const data = await client.post("/trace-links", {
             tenant,
@@ -43,6 +45,7 @@ export function registerTraceabilityCommands(program, client) {
             targetRequirementId: opts.target,
             linkType: opts.type,
             description: opts.description,
+            rationale: opts.rationale,
         });
         if (isJsonMode()) {
             output(data);
@@ -61,6 +64,98 @@ export function registerTraceabilityCommands(program, client) {
         await client.delete(`/trace-links/${tenant}/${project}/${linkId}`);
         console.log("Trace link deleted.");
     });
+    cmd
+        .command("update")
+        .description("Update a trace link (description, rationale, or type)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<link-id>", "Link ID")
+        .option("--description <desc>", "Short description for traceability matrices")
+        .option("--rationale <text>", "Engineering justification for why this link exists")
+        .option("--type <type>", "Link type: satisfies, derives, verifies, implements, refines, conflicts")
+        .action(async (tenant, project, linkId, opts) => {
+        const body = {};
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.rationale)
+            body.rationale = opts.rationale;
+        if (opts.type)
+            body.linkType = opts.type;
+        if (Object.keys(body).length === 0) {
+            console.error("Nothing to update. Provide --description, --rationale, or --type.");
+            process.exit(1);
+        }
+        const data = await client.patch(`/trace-links/${tenant}/${project}/${linkId}`, body);
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Trace link updated.");
+        }
+    });
+    cmd
+        .command("import")
+        .description("Bulk import trace links from CSV (columns: source, target, type, description, rationale)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--file <path>", "Path to CSV file")
+        .option("--dry-run", "Validate without creating")
+        .action(async (tenant, projectKey, opts) => {
+        const content = readFileSync(opts.file, "utf-8");
+        const lines = content.split("\n").map(l => l.trim()).filter(l => l.length > 0);
+        if (lines.length < 2) {
+            console.error("CSV must have a header row and at least one data row.");
+            process.exit(1);
+        }
+        const headers = lines[0].split(",").map(h => h.trim().toLowerCase());
+        const srcIdx = headers.findIndex(h => h === "source" || h === "sourcerequirementid");
+        const tgtIdx = headers.findIndex(h => h === "target" || h === "targetrequirementid");
+        const typeIdx = headers.findIndex(h => h === "type" || h === "linktype");
+        const descIdx = headers.findIndex(h => h === "description");
+        const ratIdx = headers.findIndex(h => h === "rationale");
+        if (srcIdx === -1 || tgtIdx === -1 || typeIdx === -1) {
+            console.error("CSV must have source, target, and type columns.");
+            process.exit(1);
+        }
+        const rows = lines.slice(1);
+        let created = 0;
+        let errors = 0;
+        for (let i = 0; i < rows.length; i++) {
+            const cols = rows[i].split(",").map(c => c.trim());
+            const source = cols[srcIdx];
+            const target = cols[tgtIdx];
+            const linkType = cols[typeIdx];
+            if (!source || !target || !linkType) {
+                errors++;
+                continue;
+            }
+            if (opts.dryRun) {
+                console.log(`  [dry-run] ${source} --${linkType}--> ${target}`);
+                created++;
+                continue;
+            }
+            try {
+                const body = {
+                    tenant,
+                    projectKey,
+                    sourceRequirementId: source,
+                    targetRequirementId: target,
+                    linkType,
+                };
+                if (descIdx >= 0 && cols[descIdx])
+                    body.description = cols[descIdx];
+                if (ratIdx >= 0 && cols[ratIdx])
+                    body.rationale = cols[ratIdx];
+                await client.post("/trace-links", body);
+                created++;
+            }
+            catch (err) {
+                console.error(`  Row ${i + 2}: ${err instanceof Error ? err.message : String(err)}`);
+                errors++;
+            }
+        }
+        console.log(`${opts.dryRun ? "Would create" : "Created"} ${created} trace links. Errors: ${errors}.`);
+    });
     // Linksets
     const linksets = cmd.command("linksets").description("Document linksets");
     linksets

package/package.json

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