airgen-cli 0.19.1 → 0.20.1

package/dist/commands/lint.js

@@ -693,7 +693,7 @@ export function registerLintCommands(program, client) {
         .option("--threshold <n>", "Jaccard similarity threshold (0.0-1.0)", "0.6")
         .option("--spray-threshold <n>", "Outgoing trace link count for spray pattern detection", "8")
         .option("--min-severity <level>", "Only show findings at this severity or above: low, medium, high", "low")
-        .option("--substrate-namespace <ns>", "Use existing Substrate entity classifications instead of re-classifying (e.g. SE, SE:naval)")
+        .option("--substrate-namespace <ns>", "Substrate namespace for entity lookups (default: SE)", "SE")
         .action(async (tenant, project, opts) => {
         const uht = new UhtClient();
         if (!uht.isConfigured) {
@@ -722,14 +722,13 @@ export function registerLintCommands(program, client) {
         const conceptRefs = extractConcepts(requirements);
         const top = topConcepts(conceptRefs, maxConcepts);
         console.error(`  ${conceptRefs.size} unique concepts found, classifying top ${top.length}.`);
-        // Step 3: Classify concepts — use Substrate namespace if provided, else fresh classify
-        const ns = opts.substrateNamespace;
-        console.error(ns
-            ? `Looking up concepts in Substrate namespace "${ns}"...`
-            : "Classifying concepts via UHT...");
+        // Step 3: Classify concepts — use Substrate namespace (default: SE) for pre-classified entities
+        // Only falls back to fresh POST /classify for concepts not found in the namespace
+        const ns = opts.substrateNamespace ?? "SE";
+        console.error(`Looking up concepts in Substrate namespace "${ns}"...`);
         const concepts = [];
-        if (ns) {
-            // Namespace mode: look up pre-classified entities
+        {
+            // Namespace mode: look up pre-classified entities, fall back to fresh classify
             const lookupResults = await parallelMap(top, async ([name]) => uht.lookupEntity(name, ns), 5);
             for (let i = 0; i < lookupResults.length; i++) {
                 const [name, refs] = top[i];
@@ -765,28 +764,6 @@ export function registerLintCommands(program, client) {
                 }
             }
         }
-        else {
-            // Fresh classification mode (original behavior)
-            const classifyResults = await parallelMap(top, async ([name]) => uht.classify(name), 5);
-            for (let i = 0; i < classifyResults.length; i++) {
-                const entry = classifyResults[i];
-                const [name, refs] = top[i];
-                if (entry.result) {
-                    const traitNames = entry.result.traits.map(t => t.name).filter(Boolean);
-                    concepts.push({
-                        name,
-                        hexCode: entry.result.hex_code,
-                        traits: traitNames,
-                        traitSet: new Set(traitNames),
-                        reqs: refs,
-                    });
-                    console.error(`  ✓ ${name} → ${entry.result.hex_code} (${traitNames.length} traits)`);
-                }
-                else if (entry.error) {
-                    console.error(`  ✗ ${name}: ${entry.error.message}`);
-                }
-            }
-        }
         // Step 4: Cross-compare concepts in batches
         console.error("Cross-comparing concepts...");
         const comparisons = [];

package/dist/commands/traceability.js

@@ -1,5 +1,11 @@
 import { readFileSync } from "node:fs";
 import { output, printTable, isJsonMode } from "../output.js";
+function sourceRef(l) {
+    return l.sourceRequirement?.ref ?? l.sourceRequirementId ?? "";
+}
+function targetRef(l) {
+    return l.targetRequirement?.ref ?? l.targetRequirementId ?? "";
+}
 export function registerTraceabilityCommands(program, client) {
     const cmd = program.command("traces").alias("trace").description("Traceability links");
     cmd
@@ -28,8 +34,8 @@ export function registerTraceabilityCommands(program, client) {
             console.log(`Trace links: ${links.length}${total > links.length ? ` of ${total}` : ""}\n`);
             printTable(["ID", "Source", "Target", "Type", "Description"], links.map(l => [
                 l.id,
-                l.sourceRef ?? l.sourceRequirementId ?? "",
-                l.targetRef ?? l.targetRequirementId ?? "",
+                sourceRef(l),
+                targetRef(l),
                 l.linkType ?? "",
                 l.description ?? "",
             ]));
@@ -164,6 +170,66 @@ export function registerTraceabilityCommands(program, client) {
         }
         console.log(`${opts.dryRun ? "Would create" : "Created"} ${created} trace links. Errors: ${errors}.`);
     });
+    // ── trace validate: check link direction conventions ──
+    cmd
+        .command("validate")
+        .description("Validate trace link directions against SE conventions (derives: parent→child, verifies: VER→target)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("--fix", "Reverse incorrectly directed links")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/trace-links/${tenant}/${project}`);
+        const links = data.traceLinks ?? [];
+        // Infer document tier from ref prefix
+        const tierOrder = { STK: 0, SYS: 1, IFC: 2, SUB: 3, ARC: 2, VER: 4, HAZ: 1 };
+        function refTier(ref) {
+            const prefix = ref.split("-")[0];
+            return tierOrder[prefix] ?? -1;
+        }
+        const issues = [];
+        for (const l of links) {
+            const src = sourceRef(l);
+            const tgt = targetRef(l);
+            const srcTier = refTier(src);
+            const tgtTier = refTier(tgt);
+            if (l.linkType === "derives" && srcTier > tgtTier && srcTier >= 0 && tgtTier >= 0) {
+                issues.push({ link: l, reason: `derives should flow parent→child (${src} tier ${srcTier} > ${tgt} tier ${tgtTier})` });
+            }
+            if (l.linkType === "verifies" && !src.startsWith("VER-") && tgt.startsWith("VER-")) {
+                issues.push({ link: l, reason: `verifies should flow VER→target, not ${src}→${tgt}` });
+            }
+        }
+        if (issues.length === 0) {
+            console.log(`All ${links.length} trace links pass direction validation.`);
+            return;
+        }
+        console.log(`Found ${issues.length} direction issue(s):\n`);
+        for (const { link, reason } of issues) {
+            console.log(`  ${sourceRef(link)} --${link.linkType}--> ${targetRef(link)}`);
+            console.log(`    ${reason}`);
+            if (opts.fix) {
+                try {
+                    // Delete old link, create reversed
+                    await client.delete(`/trace-links/${tenant}/${project}/${link.id}`);
+                    await client.post("/trace-links", {
+                        tenant, projectKey: project,
+                        sourceRequirementId: link.targetRequirementId,
+                        targetRequirementId: link.sourceRequirementId,
+                        linkType: link.linkType,
+                        description: link.description,
+                        rationale: link.rationale,
+                    });
+                    console.log(`    Fixed: reversed to ${targetRef(link)} --${link.linkType}--> ${sourceRef(link)}`);
+                }
+                catch (err) {
+                    console.error(`    Failed to fix: ${err.message}`);
+                }
+            }
+        }
+        if (!opts.fix) {
+            console.log(`\nUse --fix to reverse these links.`);
+        }
+    });
     // Linksets
     const linksets = cmd.command("linksets").description("Document linksets");
     linksets

package/package.json

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