nexarch 0.1.16 → 0.1.18

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

package/dist/commands/init-project.js

@@ -24,6 +24,8 @@ function slugify(name) {
     return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 // ─── 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$/;
 function parseEnvKeys(content) {
     return content
         .split("\n")
@@ -31,7 +33,8 @@ function parseEnvKeys(content) {
         .filter((line) => line && !line.startsWith("#"))
         .map((line) => line.replace(/^export\s+/, ""))
         .map((line) => line.split("=")[0].trim())
-        .filter((key) => /^[A-Z][A-Z0-9_]{2,}$/.test(key)); // min 3 chars, all caps
+        .filter((key) => /^[A-Z][A-Z0-9_]{2,}$/.test(key))
+        .filter((key) => !ENV_KEY_NOISE.test(key));
 }
 function detectFromGitConfig(dir) {
     const configPath = join(dir, ".git", "config");
@@ -90,6 +93,7 @@ function detectFromFilesystem(dir) {
         detected.push("pulumi");
     return detected;
 }
+const SKIP_DIRS = new Set(["node_modules", "dist", ".next", ".turbo", "build", "coverage", ".git"]);
 function collectPackageDeps(pkgPath) {
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
@@ -103,50 +107,125 @@ function collectPackageDeps(pkgPath) {
         return [];
     }
 }
-function readProjectName(pkgPath) {
+function readRootPackage(pkgPath) {
     try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        return typeof pkg.name === "string" ? pkg.name : null;
+        return JSON.parse(readFileSync(pkgPath, "utf8"));
     }
     catch {
-        return null;
+        return {};
     }
 }
-function scanProject(dir) {
-    const names = new Set();
-    let projectName = basename(dir);
-    let packageJsonCount = 0;
-    // Root package.json
-    const rootPkgPath = join(dir, "package.json");
-    if (existsSync(rootPkgPath)) {
-        packageJsonCount++;
-        const rootName = readProjectName(rootPkgPath);
-        if (rootName)
-            projectName = rootName;
-        for (const dep of collectPackageDeps(rootPkgPath))
-            names.add(dep);
-    }
-    // One level of subdirectories (monorepo packages)
-    try {
-        for (const entry of readdirSync(dir)) {
-            if (entry.startsWith(".") || entry === "node_modules" || entry === "dist")
-                continue;
-            const entryPath = join(dir, entry);
+// 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) {
+    const patterns = Array.isArray(workspaces) ? workspaces : (workspaces.packages ?? []);
+    const dirs = [];
+    for (const pattern of patterns) {
+        if (pattern.endsWith("/*")) {
+            const parent = join(rootDir, pattern.slice(0, -2));
             try {
-                if (!statSync(entryPath).isDirectory())
-                    continue;
-                const subPkgPath = join(entryPath, "package.json");
-                if (existsSync(subPkgPath)) {
-                    packageJsonCount++;
-                    for (const dep of collectPackageDeps(subPkgPath))
-                        names.add(dep);
+                for (const entry of readdirSync(parent)) {
+                    if (SKIP_DIRS.has(entry))
+                        continue;
+                    const full = join(parent, entry);
+                    try {
+                        if (statSync(full).isDirectory())
+                            dirs.push(full);
+                    }
+                    catch { }
                 }
             }
             catch { }
         }
+        else {
+            // Exact path
+            const full = join(rootDir, pattern);
+            try {
+                if (statSync(full).isDirectory())
+                    dirs.push(full);
+            }
+            catch { }
+        }
     }
-    catch { }
-    // .env files
+    return dirs;
+}
+// Collect all package.json paths: root + workspace packages + 2-level fallback
+function findPackageJsonPaths(rootDir) {
+    const paths = [];
+    const rootPkgPath = join(rootDir, "package.json");
+    if (!existsSync(rootPkgPath))
+        return paths;
+    paths.push(rootPkgPath);
+    const rootPkg = readRootPackage(rootPkgPath);
+    if (rootPkg.workspaces) {
+        // Workspace monorepo: resolve workspace dirs and find their package.json files
+        for (const wsDir of resolveWorkspaceDirs(rootDir, rootPkg.workspaces)) {
+            const pkgPath = join(wsDir, "package.json");
+            if (existsSync(pkgPath))
+                paths.push(pkgPath);
+        }
+    }
+    else {
+        // Non-workspace: scan up to 2 levels deep
+        try {
+            for (const l1 of readdirSync(rootDir)) {
+                if (SKIP_DIRS.has(l1) || l1.startsWith("."))
+                    continue;
+                const l1Path = join(rootDir, l1);
+                try {
+                    if (!statSync(l1Path).isDirectory())
+                        continue;
+                    const l1Pkg = join(l1Path, "package.json");
+                    if (existsSync(l1Pkg)) {
+                        paths.push(l1Pkg);
+                        continue;
+                    }
+                    for (const l2 of readdirSync(l1Path)) {
+                        if (SKIP_DIRS.has(l2) || l2.startsWith("."))
+                            continue;
+                        const l2Path = join(l1Path, l2);
+                        try {
+                            if (!statSync(l2Path).isDirectory())
+                                continue;
+                            const l2Pkg = join(l2Path, "package.json");
+                            if (existsSync(l2Pkg))
+                                paths.push(l2Pkg);
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return paths;
+}
+function scanProject(dir) {
+    const names = new Set();
+    let projectName = basename(dir);
+    const subPackages = [];
+    const pkgPaths = findPackageJsonPaths(dir);
+    const rootPkgPath = join(dir, "package.json");
+    for (const pkgPath of pkgPaths) {
+        const pkg = readRootPackage(pkgPath);
+        if (pkgPath === rootPkgPath) {
+            if (pkg.name)
+                projectName = pkg.name;
+        }
+        else {
+            // Record as a sub-package for enrichment task
+            const relativePath = pkgPath.replace(dir + "/", "").replace("/package.json", "");
+            subPackages.push({
+                name: pkg.name ?? relativePath,
+                relativePath,
+                packageJsonPath: pkgPath,
+            });
+        }
+        for (const dep of collectPackageDeps(pkgPath))
+            names.add(dep);
+    }
+    // .env files at root
     for (const envFile of [".env", ".env.example", ".env.local", ".env.runtime"]) {
         const envPath = join(dir, envFile);
         if (existsSync(envPath)) {
@@ -162,7 +241,7 @@ function scanProject(dir) {
         names.add(name);
     for (const name of detectFromFilesystem(dir))
         names.add(name);
-    return { projectName, packageJsonCount, detectedNames: Array.from(names) };
+    return { projectName, packageJsonCount: pkgPaths.length, detectedNames: Array.from(names), subPackages };
 }
 // ─── Relationship type selection ──────────────────────────────────────────────
 function pickRelationshipType(entityTypeCode) {
@@ -184,12 +263,12 @@ export async function initProject(args) {
     const dirArg = parseOptionValue(args, "--dir") ?? process.cwd();
     const dir = resolvePath(dirArg);
     const nameOverride = parseOptionValue(args, "--name");
-    const entityTypeOverride = parseOptionValue(args, "--entity-type") ?? "service";
+    const entityTypeOverride = parseOptionValue(args, "--entity-type") ?? "application";
     const creds = requireCredentials();
     const mcpOpts = { companyId: creds.companyId };
     if (!asJson)
         console.log(`Scanning ${dir}…`);
-    const { projectName, packageJsonCount, detectedNames } = scanProject(dir);
+    const { projectName, packageJsonCount, detectedNames, subPackages } = scanProject(dir);
     const displayName = nameOverride ?? projectName;
     const projectSlug = slugify(displayName);
     const projectExternalKey = `${entityTypeOverride}:${projectSlug}`;
@@ -254,12 +333,13 @@ export async function initProject(args) {
         : undefined;
     // Build entity list — project entity + all resolved reference entities
     const entities = [];
-    // The project itself
+    // The project itself — default subtype app_custom_built for application type
+    const projectSubtype = entityTypeOverride === "application" ? "app_custom_built" : undefined;
     entities.push({
         externalKey: projectExternalKey,
         entityTypeCode: entityTypeOverride,
+        ...(projectSubtype ? { entitySubtypeCode: projectSubtype } : {}),
         name: displayName,
-        description: `Project initialised from ${dir}`,
         confidence: 1,
         attributes: { source_dir: dir, scanned_at: nowIso, package_json_count: packageJsonCount },
     });
@@ -336,4 +416,49 @@ export async function initProject(args) {
             console.log(`  ${err.externalKey}: ${err.error} — ${err.message}`);
         }
     }
+    // ─── Enrichment task ────────────────────────────────────────────────────────
+    const readmeHints = ["README.md", "README.mdx", "docs/README.md", "docs/index.md"]
+        .filter((f) => existsSync(join(dir, f)));
+    console.log(`
+╔══════════════════════════════════════════════════════════════════╗
+║  ENRICHMENT TASK — action required                               ║
+╚══════════════════════════════════════════════════════════════════╝
+
+The mechanical scan has written a skeleton graph entry for this project.
+You now need to enrich it with meaningful content.
+
+PROJECT ENTITY  : ${projectExternalKey}
+PROJECT DIR     : ${dir}
+${readmeHints.length > 0 ? `README FILES    : ${readmeHints.join(", ")}` : "README FILES    : (none found — check docs/)"}
+
+STEP 1 — Read the project README / docs and build your understanding of:
+  • What does this project do? (business purpose, key features)
+  • Who are the users?
+  • What is the high-level architecture?
+  • Any notable technical decisions or constraints?
+
+STEP 2 — Call nexarch_upsert_entities to enrich the project entity:
+  • externalKey: "${projectExternalKey}"
+  • name: (proper product/project name from the README)
+  • description: (2–4 sentence summary of what it does and why)
+  • Preserve existing attributes, add any business context attributes you find.
+  • entityTypeCode: "${entityTypeOverride}"${entityTypeOverride === "application" ? '\n  • entitySubtypeCode: "app_custom_built"' : ""}
+${subPackages.length > 0 ? `
+STEP 3 — Register each sub-application as its own entity:
+  The scanner found ${subPackages.length} workspace package(s). For each one, call
+  nexarch_upsert_entities then nexarch_upsert_relationships to wire it to the parent.
+
+  Sub-packages detected:
+${subPackages.map((sp) => `    • ${sp.name}  (${sp.relativePath})`).join("\n")}
+
+  For each sub-package:
+    • Read its own README / package.json description if present
+    • entityTypeCode: "application", entitySubtypeCode: "app_custom_built"
+    • externalKey: "application:<slug>"  (slugify the package name)
+    • description: what this specific sub-app does
+    • Relationship: fromEntityExternalKey = "<sub-app key>",
+                    toEntityExternalKey   = "${projectExternalKey}",
+                    relationshipTypeCode  = "part_of"
+` : ""}
+Once enrichment is complete, run \`nexarch graph snapshot\` to capture the updated state.`);
 }

package/package.json

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