nexarch 0.1.22 → 0.1.24

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.22";
+const CLI_VERSION = "0.1.24";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {

package/dist/commands/init-project.js

@@ -25,7 +25,7 @@ function slugify(name) {
 }
 // ─── Project scanning ─────────────────────────────────────────────────────────
 // Noise patterns for env var keys that are internal config, not external service references
-const ENV_KEY_NOISE = /^(NODE_ENV|PORT|HOST|DEBUG|LOG_LEVEL|TZ|LANG|PATH|HOME|USER|SHELL|TERM)$|(_LOG_LEVEL|_MAX_|_MIN_|_DEFAULT_|_TIMEOUT|_DELAY|_JOBS|_INTERVAL|_LIMIT|_RETRIES|_CONCURREN|_WORKERS)$|^NEXT_PUBLIC_(APP|ADMIN|API|SITE|BASE|WEB)_URL$/;
+const ENV_KEY_NOISE = /^(NODE_ENV|PORT|HOST|DEBUG|LOG_LEVEL|TZ|LANG|PATH|HOME|USER|SHELL|TERM)$|(_LOG_LEVEL|_MAX_|_MIN_|_DEFAULT_|_TIMEOUT|_DELAY|_JOBS|_INTERVAL|_LIMIT|_RETRIES|_CONCURREN|_WORKERS)$|^NEXT_PUBLIC_(APP|ADMIN|API|SITE|BASE|WEB)_URL$|(_URL|_SECRET|_TOKEN|_KEY|_PASSWORD|_CREDENTIAL|_DSN|_URI)$/;
 function parseEnvKeys(content) {
     return content
         .split("\n")
@@ -97,9 +97,9 @@ const SKIP_DIRS = new Set(["node_modules", "dist", ".next", ".turbo", "build", "
 function collectPackageDeps(pkgPath) {
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        // devDependencies are build/test/type tooling — no architectural value
         return Object.keys({
             ...pkg.dependencies,
-            ...pkg.devDependencies,
             ...pkg.peerDependencies,
         });
     }
@@ -205,13 +205,16 @@ function scanProject(dir) {
     const names = new Set();
     let projectName = basename(dir);
     const subPackages = [];
+    let rootDepNames = new Set();
     const pkgPaths = findPackageJsonPaths(dir);
     const rootPkgPath = join(dir, "package.json");
     for (const pkgPath of pkgPaths) {
         const pkg = readRootPackage(pkgPath);
+        const deps = collectPackageDeps(pkgPath);
         if (pkgPath === rootPkgPath) {
             if (pkg.name)
                 projectName = pkg.name;
+            rootDepNames = new Set(deps);
         }
         else {
             // Record as a sub-package for enrichment task
@@ -220,9 +223,10 @@ function scanProject(dir) {
                 name: pkg.name ?? relativePath,
                 relativePath,
                 packageJsonPath: pkgPath,
+                depNames: deps,
             });
         }
-        for (const dep of collectPackageDeps(pkgPath))
+        for (const dep of deps)
             names.add(dep);
     }
     // .env files at root
@@ -241,7 +245,7 @@ function scanProject(dir) {
         names.add(name);
     for (const name of detectFromFilesystem(dir))
         names.add(name);
-    return { projectName, packageJsonCount: pkgPaths.length, detectedNames: Array.from(names), subPackages };
+    return { projectName, packageJsonCount: pkgPaths.length, detectedNames: Array.from(names), rootDepNames, subPackages };
 }
 // ─── Relationship type selection ──────────────────────────────────────────────
 function pickRelationshipType(entityTypeCode) {
@@ -268,7 +272,7 @@ export async function initProject(args) {
     const mcpOpts = { companyId: creds.companyId };
     if (!asJson)
         console.log(`Scanning ${dir}…`);
-    const { projectName, packageJsonCount, detectedNames, subPackages } = scanProject(dir);
+    const { projectName, packageJsonCount, detectedNames, rootDepNames, subPackages } = scanProject(dir);
     const displayName = nameOverride ?? projectName;
     const projectSlug = slugify(displayName);
     const projectExternalKey = `${entityTypeOverride}:${projectSlug}`;
@@ -358,12 +362,24 @@ export async function initProject(args) {
             confidence: 0.95,
         });
     }
-    // Build relationships from project entity to each resolved dependency
+    // Build a lookup from input name to resolved result for enrichment task use
+    const resolvedByInput = new Map();
+    for (const r of resolvedItems) {
+        if (r.canonicalExternalRef)
+            resolvedByInput.set(r.input, r);
+        if (r.normalised && r.canonicalExternalRef)
+            resolvedByInput.set(r.normalised, r);
+    }
+    // Build relationships — only wire root-level deps to the project entity.
+    // Sub-package deps are wired during enrichment (the agent does it per sub-app).
     const relationships = [];
     const seenRelPairs = new Set();
     for (const r of resolvedItems) {
         if (!r.canonicalExternalRef || !r.entityTypeCode)
             continue;
+        // Skip deps that don't belong to the root package — only wire root-level deps here
+        if (!rootDepNames.has(r.input) && !rootDepNames.has(r.normalised))
+            continue;
         const relType = pickRelationshipType(r.entityTypeCode);
         const pairKey = `${relType}::${projectExternalKey}::${r.canonicalExternalRef}`;
         if (seenRelPairs.has(pairKey))
@@ -465,7 +481,7 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
     Type definitions or utility package with no runtime
       → --entity-type technology_component --subtype tech_library
 
-  For each sub-package, run:
+  For each sub-package, run update-entity to register it:
 
   npx nexarch update-entity \\
     --key "<entity-type>:<slugified-package-name>" \\
@@ -474,12 +490,46 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
     --name "<human readable name>" \\
     --description "<what this package does and its role in the project>"
 
-  Then wire it to the parent project using the appropriate relationship:
-    • Deployable apps  → relationship type: part_of
-    • Shared libraries → relationship type: depends_on  (parent depends on the library)
+  Then register it as a resolvable alias so future scans don't re-surface it as a candidate:
+
+  npx nexarch register-alias \\
+    --alias "<original package name e.g. @scope/name>" \\
+    --key "<same entity-type>:<slugified-package-name>" \\
+    --name "<same human readable name>" \\
+    --entity-type "<same entity type>"
+
+  ⚠️  DIRECTION MATTERS — wire relationships as follows:
+
+  Deployable sub-apps (apps/*) are PART OF the parent — child points to parent:
+    npx nexarch add-relationship \\
+      --from "<sub-app-key>" \\
+      --to "${projectExternalKey}" \\
+      --type "part_of"
+    (FROM = the sub-app, TO = ${projectExternalKey})
+
+  Shared libraries (packages/*) are depended on by the parent — parent points to library:
+    npx nexarch add-relationship \\
+      --from "${projectExternalKey}" \\
+      --to "<library-key>" \\
+      --type "depends_on"
+    (FROM = ${projectExternalKey}, TO = the library)
+
+  ⚠️  WIRE DEPENDENCIES TO THE SUB-APP THAT DECLARES THEM, NOT TO THE PARENT.
+  After registering each sub-app/library entity, wire its npm dependencies to IT:
+    npx nexarch add-relationship \\
+      --from "<sub-app-or-library-key>" \\
+      --to "<resolved-tech-ref>" \\
+      --type "depends_on"
 
-  Relationship type reference:
-    part_of      — deployable sub-app is structurally part of the parent product
-    depends_on   — parent product depends on a shared library at runtime
+  Pre-resolved dependencies per sub-package (wire these after registering each entity):
+${subPackages.map((sp) => {
+        const resolved = sp.depNames
+            .map((d) => resolvedByInput.get(d))
+            .filter((r) => !!r?.canonicalExternalRef);
+        if (resolved.length === 0)
+            return `    • ${sp.name}: (no pre-resolved deps — check package.json manually)`;
+        const lines = resolved.map((r) => `        --to "${r.canonicalExternalRef}"  # ${r.canonicalName}`);
+        return `    • ${sp.name} (<sub-app-key> depends_on):\n${lines.join("\n")}`;
+    }).join("\n\n")}
 ` : ""}`);
 }

package/dist/commands/register-alias.js

@@ -0,0 +1,61 @@
+import process from "process";
+import { requireCredentials } from "../lib/credentials.js";
+import { callMcpTool } from "../lib/mcp.js";
+function parseFlag(args, flag) {
+    return args.includes(flag);
+}
+function parseOptionValue(args, option) {
+    const idx = args.indexOf(option);
+    if (idx === -1)
+        return null;
+    const value = args[idx + 1];
+    if (!value || value.startsWith("--"))
+        return null;
+    return value;
+}
+function parseToolText(result) {
+    const text = result.content?.[0]?.text ?? "{}";
+    return JSON.parse(text);
+}
+export async function registerAlias(args) {
+    const asJson = parseFlag(args, "--json");
+    const alias = parseOptionValue(args, "--alias");
+    const key = parseOptionValue(args, "--key");
+    const name = parseOptionValue(args, "--name");
+    const entityTypeCode = parseOptionValue(args, "--entity-type");
+    const entitySubtypeCode = parseOptionValue(args, "--subtype");
+    const description = parseOptionValue(args, "--description");
+    if (!alias) {
+        console.error("error: --alias <value> is required");
+        process.exit(1);
+    }
+    if (!key) {
+        console.error("error: --key <externalKey> is required");
+        process.exit(1);
+    }
+    if (!name) {
+        console.error("error: --name <name> is required");
+        process.exit(1);
+    }
+    if (!entityTypeCode) {
+        console.error("error: --entity-type <code> is required");
+        process.exit(1);
+    }
+    const creds = requireCredentials();
+    const mcpOpts = { companyId: creds.companyId };
+    const raw = await callMcpTool("nexarch_register_alias", {
+        alias,
+        canonicalExternalKey: key,
+        canonicalName: name,
+        entityTypeCode,
+        ...(entitySubtypeCode ? { entitySubtypeCode } : {}),
+        ...(description ? { description } : {}),
+        companyId: creds.companyId,
+    }, mcpOpts);
+    const result = parseToolText(raw);
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    console.log(`Registered alias "${result.alias}" → ${result.canonicalExternalKey}`);
+}

package/dist/index.js

@@ -13,6 +13,7 @@ import { agentIdentify } from "./commands/agent-identify.js";
 import { initProject } from "./commands/init-project.js";
 import { updateEntity } from "./commands/update-entity.js";
 import { addRelationship } from "./commands/add-relationship.js";
+import { registerAlias } from "./commands/register-alias.js";
 const [, , command, ...args] = process.argv;
 const commands = {
     login,
@@ -26,6 +27,7 @@ const commands = {
     "init-project": initProject,
     "update-entity": updateEntity,
     "add-relationship": addRelationship,
+    "register-alias": registerAlias,
 };
 async function main() {
     if (command === "agent") {
@@ -101,6 +103,17 @@ Usage:
                                --to <externalKey>    (required)
                                --type <code>         (required, e.g. part_of, depends_on)
                                --json
+  nexarch register-alias
+                      Register a company-scoped alias for an entity so future
+                      scans resolve it instead of logging it as a candidate.
+                      Use after enriching internal monorepo packages.
+                      Options: --alias <value>       (required, e.g. @scope/name)
+                               --key <externalKey>   (required)
+                               --name <name>         (required)
+                               --entity-type <code>  (required)
+                               --subtype <code>
+                               --description <text>
+                               --json
     `);
         process.exit(command ? 1 : 0);
     }

package/package.json

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