@corbat-tech/coco 1.4.0 → 1.5.0

package/dist/cli/index.js

@@ -12,11 +12,11 @@ import { z } from 'zod';
 import chalk42 from 'chalk';
 import * as p9 from '@clack/prompts';
 import { execa } from 'execa';
+import * as crypto from 'crypto';
+import { randomUUID } from 'crypto';
 import { Command } from 'commander';
 import { fileURLToPath, URL as URL$1 } from 'url';
 import JSON5 from 'json5';
-import * as crypto from 'crypto';
-import { randomUUID } from 'crypto';
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import * as http from 'http';
@@ -448,8 +448,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path43) {
-  await mkdir(dirname(path43), { recursive: true });
+async function ensureDir(path44) {
+  await mkdir(dirname(path44), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -527,8 +527,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path43) {
-  return join(path43);
+function normalizePath(path44) {
+  return join(path44);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -1260,6 +1260,224 @@ Examples:
     bashTools = [bashExecTool, bashBackgroundTool, commandExistsTool, getEnvTool];
   }
 });
+async function fileExists(filePath) {
+  try {
+    await fs23__default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_files = __esm({
+  "src/utils/files.ts"() {
+    init_errors();
+  }
+});
+
+// src/cli/repl/context/stack-detector.ts
+var stack_detector_exports = {};
+__export(stack_detector_exports, {
+  detectProjectStack: () => detectProjectStack
+});
+async function detectStack(cwd) {
+  if (await fileExists(path20__default.join(cwd, "package.json"))) return "node";
+  if (await fileExists(path20__default.join(cwd, "Cargo.toml"))) return "rust";
+  if (await fileExists(path20__default.join(cwd, "pyproject.toml"))) return "python";
+  if (await fileExists(path20__default.join(cwd, "go.mod"))) return "go";
+  if (await fileExists(path20__default.join(cwd, "pom.xml"))) return "java";
+  if (await fileExists(path20__default.join(cwd, "build.gradle"))) return "java";
+  if (await fileExists(path20__default.join(cwd, "build.gradle.kts"))) return "java";
+  return "unknown";
+}
+async function detectPackageManager2(cwd, stack) {
+  if (stack === "rust") return "cargo";
+  if (stack === "python") return "pip";
+  if (stack === "go") return "go";
+  if (stack === "java") {
+    if (await fileExists(path20__default.join(cwd, "build.gradle")) || await fileExists(path20__default.join(cwd, "build.gradle.kts"))) {
+      return "gradle";
+    }
+    if (await fileExists(path20__default.join(cwd, "pom.xml"))) {
+      return "maven";
+    }
+  }
+  if (stack === "node") {
+    if (await fileExists(path20__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists(path20__default.join(cwd, "yarn.lock"))) return "yarn";
+    if (await fileExists(path20__default.join(cwd, "bun.lockb"))) return "bun";
+    return "npm";
+  }
+  return null;
+}
+async function parsePackageJson(cwd) {
+  const packageJsonPath = path20__default.join(cwd, "package.json");
+  try {
+    const content = await fs23__default.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    const frameworks = [];
+    if (allDeps.react) frameworks.push("React");
+    if (allDeps.vue) frameworks.push("Vue");
+    if (allDeps["@angular/core"]) frameworks.push("Angular");
+    if (allDeps.next) frameworks.push("Next.js");
+    if (allDeps.nuxt) frameworks.push("Nuxt");
+    if (allDeps.express) frameworks.push("Express");
+    if (allDeps.fastify) frameworks.push("Fastify");
+    if (allDeps.nestjs || allDeps["@nestjs/core"]) frameworks.push("NestJS");
+    const buildTools2 = [];
+    if (allDeps.webpack) buildTools2.push("webpack");
+    if (allDeps.vite) buildTools2.push("vite");
+    if (allDeps.rollup) buildTools2.push("rollup");
+    if (allDeps.tsup) buildTools2.push("tsup");
+    if (allDeps.esbuild) buildTools2.push("esbuild");
+    if (pkg.scripts?.build) buildTools2.push("build");
+    const testingFrameworks = [];
+    if (allDeps.vitest) testingFrameworks.push("vitest");
+    if (allDeps.jest) testingFrameworks.push("jest");
+    if (allDeps.mocha) testingFrameworks.push("mocha");
+    if (allDeps.chai) testingFrameworks.push("chai");
+    if (allDeps["@playwright/test"]) testingFrameworks.push("playwright");
+    if (allDeps.cypress) testingFrameworks.push("cypress");
+    const languages = ["JavaScript"];
+    if (allDeps.typescript || await fileExists(path20__default.join(cwd, "tsconfig.json"))) {
+      languages.push("TypeScript");
+    }
+    return {
+      dependencies: allDeps,
+      frameworks,
+      buildTools: buildTools2,
+      testingFrameworks,
+      languages
+    };
+  } catch {
+    return {
+      dependencies: {},
+      frameworks: [],
+      buildTools: [],
+      testingFrameworks: [],
+      languages: []
+    };
+  }
+}
+async function parsePomXml(cwd) {
+  const pomPath = path20__default.join(cwd, "pom.xml");
+  try {
+    const content = await fs23__default.readFile(pomPath, "utf-8");
+    const dependencies = {};
+    const frameworks = [];
+    const buildTools2 = ["maven"];
+    const testingFrameworks = [];
+    const depRegex = /<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>/g;
+    let match;
+    while ((match = depRegex.exec(content)) !== null) {
+      const groupId = match[1];
+      const artifactId = match[2];
+      if (!groupId || !artifactId) continue;
+      const fullName = `${groupId}:${artifactId}`;
+      dependencies[fullName] = "unknown";
+      if (artifactId.includes("spring-boot")) {
+        if (!frameworks.includes("Spring Boot")) frameworks.push("Spring Boot");
+      }
+      if (artifactId.includes("spring-webmvc") || artifactId.includes("spring-web")) {
+        if (!frameworks.includes("Spring MVC")) frameworks.push("Spring MVC");
+      }
+      if (artifactId.includes("hibernate")) {
+        if (!frameworks.includes("Hibernate")) frameworks.push("Hibernate");
+      }
+      if (artifactId === "junit-jupiter" || artifactId === "junit") {
+        if (!testingFrameworks.includes("JUnit")) testingFrameworks.push("JUnit");
+      }
+      if (artifactId === "mockito-core") {
+        if (!testingFrameworks.includes("Mockito")) testingFrameworks.push("Mockito");
+      }
+    }
+    return { dependencies, frameworks, buildTools: buildTools2, testingFrameworks };
+  } catch {
+    return { dependencies: {}, frameworks: [], buildTools: ["maven"], testingFrameworks: [] };
+  }
+}
+async function parsePyprojectToml(cwd) {
+  const pyprojectPath = path20__default.join(cwd, "pyproject.toml");
+  try {
+    const content = await fs23__default.readFile(pyprojectPath, "utf-8");
+    const dependencies = {};
+    const frameworks = [];
+    const buildTools2 = ["pip"];
+    const testingFrameworks = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.match(/^["']?[\w-]+["']?\s*=\s*["'][\^~>=<]+[\d.]+["']/)) {
+        const depMatch = trimmed.match(/^["']?([\w-]+)["']?\s*=\s*["']([\^~>=<]+[\d.]+)["']/);
+        if (depMatch && depMatch[1] && depMatch[2]) {
+          dependencies[depMatch[1]] = depMatch[2];
+        }
+      }
+      if (trimmed.includes("fastapi")) frameworks.push("FastAPI");
+      if (trimmed.includes("django")) frameworks.push("Django");
+      if (trimmed.includes("flask")) frameworks.push("Flask");
+      if (trimmed.includes("pytest")) testingFrameworks.push("pytest");
+      if (trimmed.includes("unittest")) testingFrameworks.push("unittest");
+    }
+    return { dependencies, frameworks, buildTools: buildTools2, testingFrameworks };
+  } catch {
+    return { dependencies: {}, frameworks: [], buildTools: ["pip"], testingFrameworks: [] };
+  }
+}
+async function detectProjectStack(cwd) {
+  const stack = await detectStack(cwd);
+  const packageManager = await detectPackageManager2(cwd, stack);
+  let dependencies = {};
+  let frameworks = [];
+  let buildTools2 = [];
+  let testingFrameworks = [];
+  let languages = [];
+  if (stack === "node") {
+    const parsed = await parsePackageJson(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = parsed.languages;
+  } else if (stack === "java") {
+    const parsed = await parsePomXml(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = ["Java"];
+  } else if (stack === "python") {
+    const parsed = await parsePyprojectToml(cwd);
+    dependencies = parsed.dependencies;
+    frameworks = parsed.frameworks;
+    buildTools2 = parsed.buildTools;
+    testingFrameworks = parsed.testingFrameworks;
+    languages = ["Python"];
+  } else if (stack === "go") {
+    languages = ["Go"];
+    buildTools2 = ["go"];
+  } else if (stack === "rust") {
+    languages = ["Rust"];
+    buildTools2 = ["cargo"];
+  }
+  return {
+    stack,
+    packageManager,
+    dependencies,
+    frameworks,
+    buildTools: buildTools2,
+    testingFrameworks,
+    languages
+  };
+}
+var init_stack_detector = __esm({
+  "src/cli/repl/context/stack-detector.ts"() {
+    init_files();
+  }
+});
 function findPackageJson() {
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 10; i++) {
@@ -1418,8 +1636,8 @@ Generated by Corbat-Coco v0.1.0
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path43, options) => {
-    await runInit(path43, options);
+  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path44, options) => {
+    await runInit(path44, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -1498,18 +1716,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path43) {
-  const name = path43 === "." ? "my-project" : path43.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path44) {
+  const name = path44 === "." ? "my-project" : path44.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path43) {
+async function checkExistingProject(path44) {
   try {
-    const fs43 = await import('fs/promises');
-    await fs43.access(`${path43}/.coco`);
+    const fs44 = await import('fs/promises');
+    await fs44.access(`${path44}/.coco`);
     return true;
   } catch {
     return false;
@@ -8368,20 +8586,20 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path43) {
-          const fs43 = await import('fs/promises');
-          return fs43.readFile(path43, "utf-8");
+        async read(path44) {
+          const fs44 = await import('fs/promises');
+          return fs44.readFile(path44, "utf-8");
         },
-        async write(path43, content) {
-          const fs43 = await import('fs/promises');
+        async write(path44, content) {
+          const fs44 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs43.mkdir(nodePath.dirname(path43), { recursive: true });
-          await fs43.writeFile(path43, content, "utf-8");
+          await fs44.mkdir(nodePath.dirname(path44), { recursive: true });
+          await fs44.writeFile(path44, content, "utf-8");
         },
-        async exists(path43) {
-          const fs43 = await import('fs/promises');
+        async exists(path44) {
+          const fs44 = await import('fs/promises');
           try {
-            await fs43.access(path43);
+            await fs44.access(path44);
             return true;
           } catch {
             return false;
@@ -8620,16 +8838,16 @@ async function loadTasks(_options) {
   ];
 }
 async function checkProjectState() {
-  const fs43 = await import('fs/promises');
+  const fs44 = await import('fs/promises');
   let hasProject = false;
   let hasPlan = false;
   try {
-    await fs43.access(".coco");
+    await fs44.access(".coco");
     hasProject = true;
   } catch {
   }
   try {
-    await fs43.access(".coco/planning/backlog.json");
+    await fs44.access(".coco/planning/backlog.json");
     hasPlan = true;
   } catch {
   }
@@ -8733,24 +8951,24 @@ function getPhaseStatusForPhase(phase) {
   return "in_progress";
 }
 async function loadProjectState(cwd, config) {
-  const fs43 = await import('fs/promises');
-  const path43 = await import('path');
-  const statePath = path43.join(cwd, ".coco", "state.json");
-  const backlogPath = path43.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path43.join(cwd, ".coco", "checkpoints");
+  const fs44 = await import('fs/promises');
+  const path44 = await import('path');
+  const statePath = path44.join(cwd, ".coco", "state.json");
+  const backlogPath = path44.join(cwd, ".coco", "planning", "backlog.json");
+  const checkpointDir = path44.join(cwd, ".coco", "checkpoints");
   let currentPhase = "idle";
   let metrics;
   let sprint;
   let checkpoints = [];
   try {
-    const stateContent = await fs43.readFile(statePath, "utf-8");
+    const stateContent = await fs44.readFile(statePath, "utf-8");
     const stateData = JSON.parse(stateContent);
     currentPhase = stateData.currentPhase || "idle";
     metrics = stateData.metrics;
   } catch {
   }
   try {
-    const backlogContent = await fs43.readFile(backlogPath, "utf-8");
+    const backlogContent = await fs44.readFile(backlogPath, "utf-8");
     const backlogData = JSON.parse(backlogContent);
     if (backlogData.currentSprint) {
       const tasks = backlogData.tasks || [];
@@ -8772,7 +8990,7 @@ async function loadProjectState(cwd, config) {
   } catch {
   }
   try {
-    const files = await fs43.readdir(checkpointDir);
+    const files = await fs44.readdir(checkpointDir);
     checkpoints = files.filter((f) => f.endsWith(".json")).sort().reverse();
   } catch {
   }
@@ -8908,8 +9126,8 @@ async function restoreFromCheckpoint(_checkpoint) {
 }
 async function checkProjectExists() {
   try {
-    const fs43 = await import('fs/promises');
-    await fs43.access(".coco");
+    const fs44 = await import('fs/promises');
+    await fs44.access(".coco");
     return true;
   } catch {
     return false;
@@ -9570,12 +9788,12 @@ async function loadConfig2() {
   };
 }
 async function saveConfig(config) {
-  const fs43 = await import('fs/promises');
-  await fs43.mkdir(".coco", { recursive: true });
-  await fs43.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
+  const fs44 = await import('fs/promises');
+  await fs44.mkdir(".coco", { recursive: true });
+  await fs44.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path43) {
-  const keys = path43.split(".");
+function getNestedValue(obj, path44) {
+  const keys = path44.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -9585,8 +9803,8 @@ function getNestedValue(obj, path43) {
   }
   return current;
 }
-function setNestedValue(obj, path43, value) {
-  const keys = path43.split(".");
+function setNestedValue(obj, path44, value) {
+  const keys = path44.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -9807,8 +10025,8 @@ var MCPRegistryImpl = class {
   /**
    * Ensure directory exists
    */
-  async ensureDir(path43) {
-    await mkdir(dirname(path43), { recursive: true });
+  async ensureDir(path44) {
+    await mkdir(dirname(path44), { recursive: true });
   }
 };
 function createMCPRegistry(registryPath) {
@@ -10327,9 +10545,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path43, level) {
+function createMissingMemoryFile(path44, level) {
   return {
-    path: path43,
+    path: path44,
     level,
     content: "",
     sections: [],
@@ -10506,9 +10724,45 @@ function getConversationContext(session, toolRegistry) {
 # Project Instructions (from COCO.md/CLAUDE.md)
 
 ${session.memoryContext.combinedContent}`;
+  }
+  if (session.projectContext) {
+    const stackInfo = formatStackContext(session.projectContext);
+    systemPrompt = `${systemPrompt}
+
+${stackInfo}`;
   }
   return [{ role: "system", content: systemPrompt }, ...session.messages];
 }
+function formatStackContext(ctx) {
+  const parts = [];
+  parts.push("# Project Technology Stack");
+  parts.push("");
+  parts.push(`**Language/Runtime:** ${ctx.stack}`);
+  if (ctx.packageManager) {
+    parts.push(`**Package Manager:** ${ctx.packageManager}`);
+  }
+  if (ctx.frameworks.length > 0) {
+    parts.push(`**Frameworks:** ${ctx.frameworks.join(", ")}`);
+  }
+  if (ctx.languages.length > 0) {
+    parts.push(`**Languages:** ${ctx.languages.join(", ")}`);
+  }
+  if (ctx.testingFrameworks.length > 0) {
+    parts.push(`**Testing Frameworks:** ${ctx.testingFrameworks.join(", ")}`);
+  }
+  if (ctx.buildTools.length > 0) {
+    parts.push(`**Build Tools:** ${ctx.buildTools.join(", ")}`);
+  }
+  const keyDeps = Object.entries(ctx.dependencies).slice(0, 10).map(([name, version]) => `${name}@${version}`).join(", ");
+  if (keyDeps) {
+    parts.push(`**Key Dependencies:** ${keyDeps}`);
+  }
+  parts.push("");
+  parts.push(
+    "**IMPORTANT:** When suggesting libraries, frameworks, or dependencies, ONLY recommend technologies compatible with the stack above. Do not suggest installing Node.js packages in a Java project, or Java libraries in a Python project."
+  );
+  return parts.join("\n");
+}
 function clearSession(session) {
   session.messages = [];
 }
@@ -13259,8 +13513,8 @@ async function listTrustedProjects2(trustStore) {
   p9.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path43 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p9.log.message(`  [${level}] ${path43}`);
+    const path44 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p9.log.message(`  [${level}] ${path44}`);
     p9.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p9.log.message("");
@@ -14430,7 +14684,7 @@ async function getCheckpoint(session, checkpointId) {
   return store.checkpoints.find((cp) => cp.id === checkpointId) ?? null;
 }
 async function restoreFiles(checkpoint, excludeFiles) {
-  const fs43 = await import('fs/promises');
+  const fs44 = await import('fs/promises');
   const restored = [];
   const failed = [];
   for (const fileCheckpoint of checkpoint.files) {
@@ -14438,7 +14692,7 @@ async function restoreFiles(checkpoint, excludeFiles) {
       continue;
     }
     try {
-      await fs43.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
+      await fs44.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
       restored.push(fileCheckpoint.filePath);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -14520,8 +14774,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk42.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path43, error } of result.filesFailed) {
-    const fileName = path43.split("/").pop() ?? path43;
+  for (const { path: path44, error } of result.filesFailed) {
+    const fileName = path44.split("/").pop() ?? path44;
     console.log(`${chalk42.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -15954,8 +16208,8 @@ function formatToolSummary(toolName, input) {
       return String(input.path || ".");
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path43 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path43}`;
+      const path44 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path44}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -20989,10 +21243,10 @@ var CoverageAnalyzer = class {
       join(this.projectPath, ".coverage", "coverage-summary.json"),
       join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
     ];
-    for (const path43 of possiblePaths) {
+    for (const path44 of possiblePaths) {
       try {
-        await access(path43, constants.R_OK);
-        const content = await readFile(path43, "utf-8");
+        await access(path44, constants.R_OK);
+        const content = await readFile(path44, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -25202,20 +25456,10 @@ var diffTools = [showDiffTool];
 // src/tools/review.ts
 init_registry();
 init_errors();
-
-// src/utils/files.ts
-init_errors();
-async function fileExists(filePath) {
-  try {
-    await fs23__default.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function fileExists2(path43) {
+init_files();
+async function fileExists2(path44) {
   try {
-    await access(path43);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -25305,7 +25549,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs43) => fs43.readFile(join(cwd, "package.json"), "utf-8")
+        (fs44) => fs44.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -29964,6 +30208,13 @@ var terminalOptions = {
 var marked = new Marked();
 marked.use(markedTerminal(terminalOptions));
 init_bash();
+init_files();
+
+// src/cli/repl/skills/builtin/ship/version-detector.ts
+init_files();
+
+// src/cli/repl/skills/builtin/ship/changelog.ts
+init_files();
 
 // src/cli/repl/skills/builtin/ship/steps/test-coverage.ts
 init_bash();
@@ -30038,6 +30289,8 @@ async function startRepl(options = {}) {
     process.exit(1);
   }
   initializeContextManager(session, provider);
+  const { detectProjectStack: detectProjectStack2 } = await Promise.resolve().then(() => (init_stack_detector(), stack_detector_exports));
+  session.projectContext = await detectProjectStack2(projectPath);
   await loadAllowedPaths(projectPath);
   if (await shouldShowPermissionSuggestion()) {
     await showPermissionSuggestion();