nexarch 0.9.16 → 0.9.19

package/dist/commands/init-project.js

@@ -909,6 +909,9 @@ function pickRelationshipType(toEntityTypeCode, toEntitySubtypeCode, _fromEntity
             // managed services — integrates_with is the semantically correct relationship.
             // Other platform_component subtypes (platform_runtime, platform_control_plane) use depends_on.
             return toEntitySubtypeCode === "platform_service" ? "integrates_with" : "depends_on";
+        case "application":
+            // Application-to-application: a hard runtime dependency, not a peer integration concern.
+            return "depends_on";
         case "skill":
             return "uses";
         case "technology_component":
@@ -1349,10 +1352,23 @@ export async function initProject(args) {
         if (r.normalised && r.canonicalExternalRef)
             resolvedByInput.set(r.normalised, r);
     }
+    // Build intra-monorepo lookup: normalised package name → sub-package externalKey + entityType.
+    // Used to detect workspace deps between applications in the same repo (e.g. "workspace:*" refs
+    // that won't resolve against the global reference library but should still be wired).
+    const intraMonorepoByName = new Map();
+    for (const sp of subPackages) {
+        if (!sp.externalKey)
+            continue;
+        intraMonorepoByName.set(sp.name.toLowerCase(), { externalKey: sp.externalKey, entityType: sp.entityType });
+        const norm = normalizeToken(sp.name);
+        if (norm !== sp.name.toLowerCase())
+            intraMonorepoByName.set(norm, { externalKey: sp.externalKey, entityType: sp.entityType });
+    }
     // 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
+    // - Sub-package deps that resolve to another sub-package → integrates_with
     const relationships = [];
     const seenRelPairs = new Set();
     let relationshipAddAttempts = 0;
@@ -1385,20 +1401,43 @@ export async function initProject(args) {
         if (!sp.externalKey || seenSubKeys.has(`rel:${sp.externalKey}`))
             continue;
         seenSubKeys.add(`rel:${sp.externalKey}`);
-        // Apps are part_of the top-level project
+        // Wire structural relationship to the top-level project entity:
+        // - application_component → part_of → root (component within a single deployable app)
+        // - application → root:
+        //     product root: root composes sub-app   (product is composed of its constituent apps)
+        //     application root: sub-app part_of root (treat as a bounded sub-application)
         if (sp.entityType === "application_component") {
             addRel("part_of", sp.externalKey, projectExternalKey);
         }
+        else if (sp.entityType === "application") {
+            if (entityTypeOverride === "product") {
+                addRel("composes", projectExternalKey, sp.externalKey);
+            }
+            else {
+                addRel("part_of", sp.externalKey, projectExternalKey);
+            }
+        }
         // Wire each sub-package's resolved deps to itself
         for (const dep of sp.depSpecs) {
             const r = resolvedByInput.get(dep.name);
-            if (!r?.canonicalExternalRef || !r.entityTypeCode)
+            if (r?.canonicalExternalRef && r.entityTypeCode) {
+                addRel(pickRelationshipType(r.entityTypeCode, r.entitySubtypeCode, sp.entityType), sp.externalKey, r.canonicalExternalRef, 0.9, {
+                    source: dep.source,
+                    detected_at: nowIso,
+                    ...buildVersionAttributes(dep.versionRaw, dep.source),
+                });
                 continue;
-            addRel(pickRelationshipType(r.entityTypeCode, r.entitySubtypeCode, sp.entityType), sp.externalKey, r.canonicalExternalRef, 0.9, {
-                source: dep.source,
-                detected_at: nowIso,
-                ...buildVersionAttributes(dep.versionRaw, dep.source),
-            });
+            }
+            // Check if the dep resolves to another sub-package in the same monorepo.
+            // This catches workspace:* references and local inter-app dependencies.
+            const intra = intraMonorepoByName.get(dep.name.toLowerCase())
+                ?? intraMonorepoByName.get(normalizeToken(dep.name));
+            if (intra && intra.externalKey !== sp.externalKey) {
+                addRel("depends_on", sp.externalKey, intra.externalKey, 0.85, {
+                    source: dep.source,
+                    detected_at: nowIso,
+                });
+            }
         }
     }
     // Company org is accountable_for the top-level project entity
@@ -1540,11 +1579,11 @@ export async function initProject(args) {
         if (entityTypeOverride === "application") {
             pendingSteps.push({
                 step: stepNum++,
-                action: "discover_subsystems",
-                instruction: `Review the codebase to identify functional subsystems. Examine the code structure, named modules, route layout, and any architecture documentation. Only register subsystems clearly evidenced by the codebase — do not invent them.`,
+                action: "discover_functions",
+                instruction: `Review the codebase to identify discrete application functions (what the application does). Examine named modules, route layout, service boundaries, and any architecture documentation. Register functions as application_function entities with subtype core_function (primary business function), supporting_function (auxiliary/enablement), integration_function (external connectivity), or data_function (data processing). Only register functions clearly evidenced by the codebase — do not invent them.`,
                 commandTemplates: {
-                    updateEntity: `nexarch update-entity --key "application_component:${projectSlug}-<subsystem-slug>" --entity-type application_component --subtype app_comp_subsystem --name "..." --description "..."`,
-                    addRelationship: `nexarch add-relationship --from "application_component:${projectSlug}-<subsystem-slug>" --to "${projectExternalKey}" --type part_of`,
+                    updateEntity: `nexarch update-entity --key "application_function:${projectSlug}-<function-slug>" --entity-type application_function --subtype core_function --name "..." --description "..."`,
+                    addRelationship: `nexarch add-relationship --from "application_function:${projectSlug}-<function-slug>" --to "${projectExternalKey}" --type part_of`,
                 },
             });
         }
@@ -1685,12 +1724,14 @@ export async function initProject(args) {
             lines.push(`  ${step++}. Update each sub-package listed under CLASSIFY_THESE above.`);
         }
         if (entityTypeOverride === "application") {
-            lines.push(`  ${step++}. Review the codebase to identify functional subsystems.`);
-            lines.push(`     Examine the code structure, named modules, route layout, and any architecture documentation.`);
-            lines.push(`     Only register subsystems clearly evidenced by the codebase — do not invent them.`);
+            lines.push(`  ${step++}. Review the codebase to identify discrete application functions (what the application does).`);
+            lines.push(`     Examine named modules, route layout, service boundaries, and any architecture documentation.`);
+            lines.push(`     Use subtype core_function (primary business function), supporting_function (auxiliary/enablement),`);
+            lines.push(`     integration_function (external connectivity), or data_function (data processing).`);
+            lines.push(`     Only register functions clearly evidenced by the codebase — do not invent them.`);
             lines.push(`     For each one found:`);
-            lines.push(`       nexarch update-entity --key "application_component:${projectExternalKey.split(":")[1] ?? "project"}-<subsystem-slug>" --entity-type application_component --subtype app_comp_subsystem --name "..." --description "..."`);
-            lines.push(`       nexarch add-relationship --from "application_component:${projectExternalKey.split(":")[1] ?? "project"}-<subsystem-slug>" --to "${projectExternalKey}" --type part_of`);
+            lines.push(`       nexarch update-entity --key "application_function:${projectExternalKey.split(":")[1] ?? "project"}-<function-slug>" --entity-type application_function --subtype core_function --name "..." --description "..."`);
+            lines.push(`       nexarch add-relationship --from "application_function:${projectExternalKey.split(":")[1] ?? "project"}-<function-slug>" --to "${projectExternalKey}" --type part_of`);
         }
         lines.push(`  ${step++}. Scan the READMEs for platforms/SaaS not auto-detected (Vercel, Neon, Stripe, etc.).`);
         lines.push(`       For each found: nexarch resolve-names --names "..." --json  →  nexarch update-entity  →  nexarch add-relationship`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.9.16",
+  "version": "0.9.19",
   "description": "Your architecture workspace for AI delivery.",
   "keywords": [
     "nexarch",