nexarch 0.1.23 → 0.1.25

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

package/dist/commands/init-project.js

@@ -115,6 +115,34 @@ function readRootPackage(pkgPath) {
         return {};
     }
 }
+// Guess entity type + subtype for a sub-package based on its path and package.json scripts.
+function classifySubPackage(pkgPath, relativePath) {
+    const topDir = relativePath.split("/")[0] ?? "";
+    // packages/* → shared library/component
+    if (topDir === "packages") {
+        const name = relativePath.split("/")[1] ?? "";
+        if (name.includes("ui") || name.includes("components"))
+            return { entityType: "technology_component", subtype: "tech_framework" };
+        if (name.includes("types") || name.includes("shared"))
+            return { entityType: "technology_component", subtype: "tech_library" };
+        return { entityType: "technology_component", subtype: "tech_library" };
+    }
+    // apps/* or src/* → deployable application; check scripts
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const scripts = Object.keys(pkg.scripts ?? {});
+        const hasServer = scripts.some((s) => ["start", "dev", "serve", "build"].includes(s));
+        if (hasServer) {
+            const name = relativePath.toLowerCase();
+            if (name.includes("crawl") || name.includes("worker") || name.includes("job") || name.includes("etl")) {
+                return { entityType: "application", subtype: "app_integration_service" };
+            }
+            return { entityType: "application", subtype: "app_custom_built" };
+        }
+    }
+    catch { }
+    return { entityType: "technology_component", subtype: "tech_library" };
+}
 // Resolve workspace glob patterns (e.g. "apps/*", "packages/*") to actual directories.
 // Handles the common case of a single wildcard — no full glob library needed.
 function resolveWorkspaceDirs(rootDir, workspaces) {
@@ -205,24 +233,34 @@ 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
             const relativePath = pkgPath.replace(dir + "/", "").replace("/package.json", "");
+            const packageName = pkg.name ?? relativePath;
+            const { entityType, subtype } = classifySubPackage(pkgPath, relativePath);
+            const externalKey = `${entityType}:${slugify(packageName)}`;
             subPackages.push({
-                name: pkg.name ?? relativePath,
+                name: packageName,
                 relativePath,
                 packageJsonPath: pkgPath,
+                depNames: deps,
+                entityType,
+                subtype,
+                externalKey,
             });
         }
-        for (const dep of collectPackageDeps(pkgPath))
+        for (const dep of deps)
             names.add(dep);
     }
     // .env files at root
@@ -241,7 +279,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 +306,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,23 +396,66 @@ export async function initProject(args) {
             confidence: 0.95,
         });
     }
-    // Build relationships from project entity to each resolved dependency
+    // Auto-create stub entities for each sub-package
+    const seenSubKeys = new Set();
+    for (const sp of subPackages) {
+        if (seenSubKeys.has(sp.externalKey))
+            continue;
+        seenSubKeys.add(sp.externalKey);
+        entities.push({
+            externalKey: sp.externalKey,
+            entityTypeCode: sp.entityType,
+            entitySubtypeCode: sp.subtype,
+            name: sp.name,
+            confidence: 0.8,
+            attributes: { source_dir: `${dir}/${sp.relativePath}`, scanned_at: nowIso },
+        });
+    }
+    // Build a lookup from input name to resolved result for enrichment task and sub-app wiring
+    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:
+    // - Root-level deps → wired to the top-level project entity
+    // - Sub-package deps → wired to each sub-package entity
+    // - Sub-packages that are apps → part_of the top-level project
     const relationships = [];
     const seenRelPairs = new Set();
+    function addRel(type, from, to, confidence = 0.9) {
+        const key = `${type}::${from}::${to}`;
+        if (seenRelPairs.has(key))
+            return;
+        seenRelPairs.add(key);
+        relationships.push({ relationshipTypeCode: type, fromEntityExternalKey: from, toEntityExternalKey: to, confidence });
+    }
+    // Root-level deps → top-level project
     for (const r of resolvedItems) {
         if (!r.canonicalExternalRef || !r.entityTypeCode)
             continue;
-        const relType = pickRelationshipType(r.entityTypeCode);
-        const pairKey = `${relType}::${projectExternalKey}::${r.canonicalExternalRef}`;
-        if (seenRelPairs.has(pairKey))
+        if (!rootDepNames.has(r.input) && !rootDepNames.has(r.normalised))
             continue;
-        seenRelPairs.add(pairKey);
-        relationships.push({
-            relationshipTypeCode: relType,
-            fromEntityExternalKey: projectExternalKey,
-            toEntityExternalKey: r.canonicalExternalRef,
-            confidence: 0.9,
-        });
+        addRel(pickRelationshipType(r.entityTypeCode), projectExternalKey, r.canonicalExternalRef);
+    }
+    // Sub-package relationships
+    for (const sp of subPackages) {
+        if (!sp.externalKey || seenSubKeys.has(`rel:${sp.externalKey}`))
+            continue;
+        seenSubKeys.add(`rel:${sp.externalKey}`);
+        // Apps are part_of the top-level project
+        if (sp.entityType === "application") {
+            addRel("part_of", sp.externalKey, projectExternalKey);
+        }
+        // Wire each sub-package's resolved deps to itself
+        for (const depName of sp.depNames) {
+            const r = resolvedByInput.get(depName);
+            if (!r?.canonicalExternalRef || !r.entityTypeCode)
+                continue;
+            addRel(pickRelationshipType(r.entityTypeCode), sp.externalKey, r.canonicalExternalRef);
+        }
     }
     if (!asJson)
         console.log(`\nWriting to graph…`);
@@ -497,5 +578,23 @@ ${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")
       --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"
+
+  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/package.json

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