nexarch 0.1.31 → 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.31";
+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

@@ -585,16 +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 "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/package.json

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