nexarch 0.1.30 → 0.1.32

package/dist/commands/add-relationship.js

@@ -17,6 +17,29 @@ function parseToolText(result) {
     const text = result.content?.[0]?.text ?? "{}";
     return JSON.parse(text);
 }
+async function tryCreateStubEntity(externalKey, mcpOpts, agentContext, policyContext) {
+    // Only auto-create global reference entities — company entities must be created explicitly
+    if (!externalKey.startsWith("global:"))
+        return false;
+    // Derive a normalised alias from the external key (e.g. "global:platform:vercel" → "vercel")
+    const parts = externalKey.split(":");
+    const alias = parts[parts.length - 1];
+    const resolveRaw = await callMcpTool("nexarch_resolve_reference", { names: [alias], companyId: mcpOpts.companyId }, mcpOpts);
+    const resolveResult = parseToolText(resolveRaw);
+    const match = resolveResult.results?.find((r) => r.resolved && r.canonicalExternalRef === externalKey);
+    if (!match)
+        return false;
+    const entity = {
+        externalKey,
+        entityTypeCode: match.entityTypeCode,
+        name: match.canonicalName,
+        confidence: 1,
+    };
+    if (match.entitySubtypeCode)
+        entity.entitySubtypeCode = match.entitySubtypeCode;
+    await callMcpTool("nexarch_upsert_entities", { entities: [entity], agentContext, policyContext }, mcpOpts);
+    return true;
+}
 export async function addRelationship(args) {
     const asJson = parseFlag(args, "--json");
     const fromKey = parseOptionValue(args, "--from");
@@ -58,8 +81,33 @@ export async function addRelationship(args) {
         toEntityExternalKey: toKey,
         confidence: 1,
     };
-    const raw = await callMcpTool("nexarch_upsert_relationships", { relationships: [relationship], agentContext, policyContext }, mcpOpts);
-    const result = parseToolText(raw);
+    let raw = await callMcpTool("nexarch_upsert_relationships", { relationships: [relationship], agentContext, policyContext }, mcpOpts);
+    let result = parseToolText(raw);
+    // Auto-create global reference stubs if endpoints are missing, then retry once
+    const missingEndpoint = result.errors?.some((e) => e.error === "RELATIONSHIP_ENDPOINT_NOT_FOUND");
+    if (missingEndpoint) {
+        const failedFromKeys = result.errors
+            ?.filter((e) => e.error === "RELATIONSHIP_ENDPOINT_NOT_FOUND" && e.fromEntityExternalKey)
+            .map((e) => e.fromEntityExternalKey);
+        const failedToKeys = result.errors
+            ?.filter((e) => e.error === "RELATIONSHIP_ENDPOINT_NOT_FOUND" && e.toEntityExternalKey)
+            .map((e) => e.toEntityExternalKey);
+        const keysToCreate = [...new Set([...(failedFromKeys ?? []), ...(failedToKeys ?? [])])];
+        // If no specific endpoint keys returned, fall back to trying both
+        if (keysToCreate.length === 0) {
+            keysToCreate.push(fromKey, toKey);
+        }
+        let createdAny = false;
+        for (const key of keysToCreate) {
+            const created = await tryCreateStubEntity(key, mcpOpts, agentContext, policyContext);
+            if (created)
+                createdAny = true;
+        }
+        if (createdAny) {
+            raw = await callMcpTool("nexarch_upsert_relationships", { relationships: [relationship], agentContext, policyContext }, mcpOpts);
+            result = parseToolText(raw);
+        }
+    }
     if (asJson) {
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         if (Number(result.summary?.failed ?? 0) > 0)

package/dist/commands/init-agent.js

@@ -4,7 +4,7 @@ import { join } from "path";
 import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.1.30";
+const CLI_VERSION = "0.1.32";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {

package/dist/commands/init-project.js

@@ -281,18 +281,17 @@ function scanProject(dir) {
     return { projectName, packageJsonCount: pkgPaths.length, detectedNames: Array.from(names), rootDepNames, subPackages };
 }
 // ─── Relationship type selection ──────────────────────────────────────────────
-function pickRelationshipType(toEntityTypeCode, fromEntityTypeCode = "application") {
+function pickRelationshipType(toEntityTypeCode, _fromEntityTypeCode = "application") {
     switch (toEntityTypeCode) {
         case "model":
             return "uses_model";
         case "platform":
         case "platform_component":
+            // runs_on is the valid ontology relationship from application/tech to platform
+            return "runs_on";
         case "skill":
             return "uses";
         case "technology_component":
-            // tech→tech depends_on is not allowed by ontology; use "uses" instead
-            if (fromEntityTypeCode === "technology_component")
-                return "uses";
             return "depends_on";
         default:
             return "depends_on";
@@ -544,8 +543,8 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
 
   RELATIONSHIP TYPE RULES:
     application  → technology_component  : --type "depends_on"
-    technology_component → technology_component : --type "uses"   (NOT depends_on)
-    any → platform / platform_component  : --type "uses"
+    technology_component → technology_component : --type "depends_on"
+    any → platform / platform_component  : --type "runs_on"   (NOT uses or depends_on)
     any → model                          : --type "uses_model"
 
   Pre-resolved dependencies per sub-package (wire these after registering each entity):
@@ -586,15 +585,22 @@ ${finalStep} — Identify architecturally significant components not auto-detect
   For each one you identify:
 
   1. Resolve it to a canonical reference:
-     npx nexarch resolve-names --names "<platform name>"
+     npx nexarch resolve-names --names "<platform name>" --json
 
-  2. If resolved, wire the relationship from the relevant entity:
+  2. If resolved, instantiate the entity in the graph (REQUIRED before add-relationship):
+     npx nexarch update-entity \\
+       --key "<resolved-ref>" \\
+       --entity-type "<entityTypeCode from resolve-names>" \\
+       --name "<canonicalName from resolve-names>"
+
+  3. Wire the relationship:
      npx nexarch add-relationship \\
        --from "${projectExternalKey}" \\
        --to "<resolved-ref>" \\
-       --type "uses"
+       --type "runs_on"    # for platforms (Vercel, Neon, etc.)
+       # use --type "depends_on" for external APIs/SaaS (Stripe, Resend, etc.)
 
-  3. If unresolved (not in the reference library), skip it for now — it will appear
+  4. If unresolved (not in the reference library), skip it for now — it will appear
      as a reference candidate on the next scan once you register an alias for it.
 `;
         return `

package/dist/commands/resolve-names.js

@@ -40,7 +40,7 @@ export async function resolveNames(args) {
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         return;
     }
-    for (const entry of result.resolved ?? []) {
+    for (const entry of result.results ?? []) {
         if (entry.resolved) {
             console.log(`✓ ${entry.input} → ${entry.canonicalExternalRef}  (${entry.entityTypeCode}${entry.entitySubtypeCode ? `/${entry.entitySubtypeCode}` : ""})  "${entry.canonicalName}"`);
         }
@@ -48,5 +48,5 @@ export async function resolveNames(args) {
             console.log(`✗ ${entry.input} — not found in reference library`);
         }
     }
-    console.log(`\n${result.totalResolved}/${result.totalRequested} resolved`);
+    console.log(`\n${result.summary?.resolved ?? 0}/${result.summary?.requested ?? 0} resolved`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Connect AI coding tools to your Nexarch architecture workspace",
   "keywords": [
     "nexarch",