truecourse 0.5.6 → 0.5.7

package/server.mjs

@@ -40794,7 +40794,72 @@ var init_language_config = __esm({
 
 // packages/analyzer/dist/file-discovery.js
 import { existsSync as existsSync2, readFileSync, readdirSync, statSync as statSync2 } from "fs";
+import { execFileSync } from "child_process";
 import { join, relative, resolve } from "path";
+function isInsideGitWorkTree(dir) {
+  try {
+    const out = execFileSync("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.toString("utf8").trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function buildPostGitFilter(dir) {
+  const ig = (0, import_ignore.default)();
+  const tcPath = join(dir, ".truecourseignore");
+  if (existsSync2(tcPath))
+    ig.add(readFileSync(tcPath, "utf8"));
+  ig.add(".git");
+  for (const p of getAllTestPatterns())
+    ig.add(p);
+  for (const p of getAllIgnorePatterns())
+    ig.add(p);
+  return ig;
+}
+function discoverFilesViaGit(dir) {
+  if (!isInsideGitWorkTree(dir))
+    return null;
+  let stdout;
+  try {
+    stdout = execFileSync("git", ["-C", dir, "ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", "."], { maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
+  } catch {
+    return null;
+  }
+  const relPaths = stdout.toString("utf8").split("\0").filter(Boolean);
+  relPaths.sort(compareDepthFirst);
+  const ig = buildPostGitFilter(dir);
+  const out = [];
+  for (const rel of relPaths) {
+    if (ig.ignores(rel))
+      continue;
+    const abs = join(dir, rel);
+    let isFile = false;
+    try {
+      isFile = statSync2(abs).isFile();
+    } catch {
+      continue;
+    }
+    if (!isFile)
+      continue;
+    if (detectLanguage(abs))
+      out.push(abs);
+  }
+  return out;
+}
+function compareDepthFirst(a, b) {
+  const ap = a.split("/");
+  const bp = b.split("/");
+  const len = Math.min(ap.length, bp.length);
+  for (let i = 0; i < len; i++) {
+    const x = ap[i];
+    const y = bp[i];
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return ap.length - bp.length;
+}
 function findAllGitignores(startDir) {
   const gitignores = [];
   let currentDir = resolve(startDir);
@@ -40804,25 +40869,46 @@ function findAllGitignores(startDir) {
       gitignores.unshift({ path: gitignorePath, dir: currentDir });
     }
     const parentDir = resolve(currentDir, "..");
-    if (parentDir === currentDir) {
+    if (parentDir === currentDir)
       break;
-    }
     currentDir = parentDir;
   }
   return gitignores;
 }
+function reanchorTruecourseignore(content, prefix) {
+  if (prefix === "" || prefix === ".")
+    return content;
+  return content.split("\n").map((line) => {
+    const raw = line;
+    const trimmed2 = raw.trim();
+    if (trimmed2 === "" || trimmed2.startsWith("#"))
+      return raw;
+    const negate = trimmed2.startsWith("!");
+    const body = negate ? trimmed2.slice(1) : trimmed2;
+    if (body.startsWith("**/"))
+      return raw;
+    const hasLeadingSlash = body.startsWith("/");
+    const withoutTrailing = body.endsWith("/") ? body.slice(0, -1) : body;
+    const inner = hasLeadingSlash ? withoutTrailing.slice(1) : withoutTrailing;
+    const hasInternalSlash = inner.includes("/");
+    if (!hasLeadingSlash && !hasInternalSlash)
+      return raw;
+    const stripped = hasLeadingSlash ? body.slice(1) : body;
+    return `${negate ? "!" : ""}${prefix}/${stripped}`;
+  }).join("\n");
+}
 function loadIgnorePatterns(baseDir) {
   const ig = (0, import_ignore.default)();
   const gitignores = findAllGitignores(baseDir);
   const rootDir = gitignores.length > 0 && gitignores[0] ? gitignores[0].dir : baseDir;
   for (const { path: gitignorePath } of gitignores) {
-    const content = readFileSync(gitignorePath, "utf8");
-    ig.add(content);
+    ig.add(readFileSync(gitignorePath, "utf8"));
   }
   const truecourseignorePath = join(baseDir, ".truecourseignore");
   if (existsSync2(truecourseignorePath)) {
     const content = readFileSync(truecourseignorePath, "utf8");
-    ig.add(content);
+    const prefix = relative(rootDir, baseDir).replace(/\\/g, "/");
+    ig.add(reanchorTruecourseignore(content, prefix));
   }
   ig.add(".git");
   for (const pattern of getAllTestPatterns())
@@ -40831,7 +40917,7 @@ function loadIgnorePatterns(baseDir) {
     ig.add(pattern);
   return { ig, rootDir };
 }
-function discoverFiles(dir) {
+function discoverFilesViaWalker(dir) {
   const files = [];
   const { ig, rootDir } = loadIgnorePatterns(dir);
   function traverse(currentPath) {
@@ -40842,23 +40928,27 @@ function discoverFiles(dir) {
         const relativePath = relative(rootDir, fullPath);
         const stat = statSync2(fullPath);
         const pathToCheck = stat.isDirectory() ? relativePath + "/" : relativePath;
-        if (ig.ignores(pathToCheck)) {
+        if (ig.ignores(pathToCheck))
           continue;
-        }
         if (stat.isDirectory()) {
           traverse(fullPath);
         } else if (stat.isFile()) {
-          if (detectLanguage(fullPath)) {
+          if (detectLanguage(fullPath))
             files.push(fullPath);
-          }
         }
       }
-    } catch (error) {
+    } catch {
     }
   }
   traverse(dir);
   return files;
 }
+function discoverFiles(dir) {
+  const viaGit = discoverFilesViaGit(dir);
+  if (viaGit !== null)
+    return viaGit;
+  return discoverFilesViaWalker(dir);
+}
 var import_ignore;
 var init_file_discovery = __esm({
   "packages/analyzer/dist/file-discovery.js"() {
@@ -140509,6 +140599,30 @@ function createSocketLlmEstimateHandler(repoId) {
     }
   });
 }
+function createSocketStashConfirmHandler(repoId) {
+  return (info) => new Promise((resolve7) => {
+    const io3 = getIO();
+    const room = `repo:${repoId}`;
+    io3.to(room).emit("analysis:stash-confirm-request", {
+      repoId,
+      modifiedCount: info.modifiedCount,
+      untrackedCount: info.untrackedCount
+    });
+    function onResponse(data) {
+      if (data.repoId !== repoId) return;
+      cleanup();
+      resolve7(data.choice);
+    }
+    function cleanup() {
+      for (const [, socket] of io3.sockets.sockets) {
+        socket.removeListener("analysis:stash-confirm-response", onResponse);
+      }
+    }
+    for (const [, socket] of io3.sockets.sockets) {
+      socket.on("analysis:stash-confirm-response", onResponse);
+    }
+  });
+}
 
 // apps/dashboard/server/src/socket/index.ts
 var io2 = null;
@@ -145631,9 +145745,9 @@ function deleteDiff(repoPath) {
 // packages/core/dist/commands/analyze-core.js
 init_logger();
 import { randomUUID as randomUUID6 } from "node:crypto";
+import path12 from "node:path";
 
 // packages/core/dist/services/analyzer.service.js
-import path11 from "node:path";
 init_logger();
 init_dist2();
 function runDeterministicModuleChecks(result, enabledDeterministic) {
@@ -145668,150 +145782,122 @@ function runDeterministicServiceChecks(result, enabledDeterministic) {
 }
 async function runAnalysis(repoPath, _branch, onProgress, options) {
   let currentBranch = "unknown";
-  let didStash = false;
-  let isSubdirectory = false;
-  let hasChanges = false;
-  let git;
   if (!options?.skipGit) {
-    git = await getGit(repoPath);
+    const git = await getGit(repoPath);
     currentBranch = (await git.branch()).current;
-    const statusResult = await git.status();
-    hasChanges = !statusResult.isClean();
-    const gitRoot = (await git.revparse(["--show-toplevel"])).trim();
-    isSubdirectory = path11.resolve(repoPath) !== path11.resolve(gitRoot);
   }
-  if (hasChanges && !options?.skipStash && !isSubdirectory && git) {
-    onProgress({ step: "stash", percent: 2, detail: "Stashing pending changes to analyze committed state..." });
+  onProgress({ step: "discover", percent: 10, detail: "Discovering files..." });
+  const analyzer = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  await analyzer.initParsers();
+  const files = await analyzer.discoverFiles(repoPath);
+  onProgress({
+    step: "discover",
+    percent: 15,
+    detail: `Found ${files.length} files`
+  });
+  onProgress({ step: "analyze", percent: 20, detail: "Analyzing files..." });
+  const fileAnalyses = [];
+  const totalFiles = files.length;
+  for (let i = 0; i < totalFiles; i++) {
+    if (options?.signal?.aborted)
+      throw new DOMException("Analysis cancelled", "AbortError");
+    const file = files[i];
     try {
-      const stashResult = await git.stash(["push", "--include-untracked", "-m", "truecourse-analysis-stash"]);
-      didStash = !stashResult.includes("No local changes");
+      const analysis = await analyzer.analyzeFile(file);
+      if (analysis) {
+        fileAnalyses.push(analysis);
+      }
     } catch (error) {
-      log.warn(`[Analyzer] Failed to stash changes, analyzing current state: ${error instanceof Error ? error.message : String(error)}`);
+      log.warn(`[Analyzer] Failed to analyze ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (i % 10 === 0 || i === totalFiles - 1) {
+      const analyzePercent = 20 + Math.round((i + 1) / totalFiles * 40);
+      onProgress({
+        step: "analyze",
+        percent: analyzePercent,
+        detail: `Analyzed ${i + 1}/${totalFiles} files`
+      });
     }
   }
-  try {
-    onProgress({ step: "discover", percent: 10, detail: "Discovering files..." });
-    const analyzer = await Promise.resolve().then(() => (init_dist2(), dist_exports));
-    await analyzer.initParsers();
-    const files = await analyzer.discoverFiles(repoPath);
-    onProgress({
-      step: "discover",
-      percent: 15,
-      detail: `Found ${files.length} files`
-    });
-    onProgress({ step: "analyze", percent: 20, detail: "Analyzing files..." });
-    const fileAnalyses = [];
-    const totalFiles = files.length;
-    for (let i = 0; i < totalFiles; i++) {
-      if (options?.signal?.aborted)
-        throw new DOMException("Analysis cancelled", "AbortError");
-      const file = files[i];
-      try {
-        const analysis = await analyzer.analyzeFile(file);
-        if (analysis) {
-          fileAnalyses.push(analysis);
-        }
-      } catch (error) {
-        log.warn(`[Analyzer] Failed to analyze ${file}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      if (i % 10 === 0 || i === totalFiles - 1) {
-        const analyzePercent = 20 + Math.round((i + 1) / totalFiles * 40);
-        onProgress({
-          step: "analyze",
-          percent: analyzePercent,
-          detail: `Analyzed ${i + 1}/${totalFiles} files`
-        });
+  onProgress({
+    step: "dependencies",
+    percent: 65,
+    detail: "Building dependency graph..."
+  });
+  const scopedOptions = buildScopedCompilerOptions(repoPath);
+  if (scopedOptions.length > 0) {
+    const filePaths = fileAnalyses.map((fa) => fa.filePath);
+    const { exportMap } = analyzeSemantics(filePaths, scopedOptions);
+    for (const fa of fileAnalyses) {
+      const fileExports = exportMap.get(fa.filePath);
+      if (!fileExports)
+        continue;
+      const defaultExportedFn = fa.exports.find((e) => e.isDefault)?.name;
+      for (const fn of fa.functions) {
+        fn.isExported = fileExports.has(fn.name) || fileExports.has("default") && fn.name === defaultExportedFn;
       }
     }
-    onProgress({
-      step: "dependencies",
-      percent: 65,
-      detail: "Building dependency graph..."
-    });
-    const scopedOptions = buildScopedCompilerOptions(repoPath);
-    if (scopedOptions.length > 0) {
-      const filePaths = fileAnalyses.map((fa) => fa.filePath);
-      const { exportMap } = analyzeSemantics(filePaths, scopedOptions);
-      for (const fa of fileAnalyses) {
+  }
+  const filesByLanguage = /* @__PURE__ */ new Map();
+  for (const fa of fileAnalyses) {
+    const list = filesByLanguage.get(fa.language) || [];
+    list.push(fa);
+    filesByLanguage.set(fa.language, list);
+  }
+  for (const [language, files2] of filesByLanguage) {
+    const serverConfig = getLspServerConfig(language);
+    if (!serverConfig)
+      continue;
+    try {
+      const lspClient = new LspClient(serverConfig);
+      await lspClient.start(repoPath);
+      const filePaths = files2.map((fa) => fa.filePath);
+      const { exportMap } = await lspClient.analyzeSemantics(filePaths.map((fp) => fp.startsWith(repoPath) ? fp.slice(repoPath.length + 1) : fp));
+      for (const fa of files2) {
         const fileExports = exportMap.get(fa.filePath);
         if (!fileExports)
           continue;
-        const defaultExportedFn = fa.exports.find((e) => e.isDefault)?.name;
         for (const fn of fa.functions) {
-          fn.isExported = fileExports.has(fn.name) || fileExports.has("default") && fn.name === defaultExportedFn;
+          fn.isExported = fileExports.has(fn.name);
         }
       }
-    }
-    const filesByLanguage = /* @__PURE__ */ new Map();
-    for (const fa of fileAnalyses) {
-      const list = filesByLanguage.get(fa.language) || [];
-      list.push(fa);
-      filesByLanguage.set(fa.language, list);
-    }
-    for (const [language, files2] of filesByLanguage) {
-      const serverConfig = getLspServerConfig(language);
-      if (!serverConfig)
-        continue;
-      try {
-        const lspClient = new LspClient(serverConfig);
-        await lspClient.start(repoPath);
-        const filePaths = files2.map((fa) => fa.filePath);
-        const { exportMap } = await lspClient.analyzeSemantics(filePaths.map((fp) => fp.startsWith(repoPath) ? fp.slice(repoPath.length + 1) : fp));
-        for (const fa of files2) {
-          const fileExports = exportMap.get(fa.filePath);
-          if (!fileExports)
-            continue;
-          for (const fn of fa.functions) {
-            fn.isExported = fileExports.has(fn.name);
-          }
-        }
-        await lspClient.stop();
-      } catch (error) {
-        log.warn(`[Analyzer] ${serverConfig.name} LSP analysis failed, using tree-sitter heuristics: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    const moduleDependencies = analyzer.buildDependencyGraph(fileAnalyses, repoPath);
-    onProgress({
-      step: "services",
-      percent: 75,
-      detail: "Detecting services..."
-    });
-    const splitResult = analyzer.performSplitAnalysis(repoPath, fileAnalyses, moduleDependencies);
-    onProgress({
-      step: "saving",
-      percent: 80,
-      detail: `Saving results: ${splitResult.services.length} services detected`
-    });
-    return {
-      architecture: splitResult.architecture,
-      services: splitResult.services,
-      dependencies: splitResult.dependencies,
-      layerDetails: splitResult.layerDetails,
-      databaseResult: splitResult.databaseResult,
-      modules: splitResult.modules,
-      methods: splitResult.methods,
-      moduleLevelDependencies: splitResult.moduleLevelDependencies,
-      methodLevelDependencies: splitResult.methodLevelDependencies,
-      fileAnalyses,
-      moduleDependencies,
-      entryPointFiles: new Set(findEntryPoints(fileAnalyses, moduleDependencies)),
-      metadata: {
-        totalFiles: files.length,
-        analyzedFiles: fileAnalyses.length,
-        branch: currentBranch || "HEAD",
-        analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  } finally {
-    if (didStash && git) {
-      onProgress({ step: "unstash", percent: 80, detail: "Restoring pending changes..." });
-      try {
-        await git.stash(["pop"]);
-      } catch (error) {
-        log.error(`[Analyzer] Failed to restore stashed changes. Run "git stash pop" manually. ${error instanceof Error ? error.message : String(error)}`);
-      }
+      await lspClient.stop();
+    } catch (error) {
+      log.warn(`[Analyzer] ${serverConfig.name} LSP analysis failed, using tree-sitter heuristics: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  const moduleDependencies = analyzer.buildDependencyGraph(fileAnalyses, repoPath);
+  onProgress({
+    step: "services",
+    percent: 75,
+    detail: "Detecting services..."
+  });
+  const splitResult = analyzer.performSplitAnalysis(repoPath, fileAnalyses, moduleDependencies);
+  onProgress({
+    step: "saving",
+    percent: 80,
+    detail: `Saving results: ${splitResult.services.length} services detected`
+  });
+  return {
+    architecture: splitResult.architecture,
+    services: splitResult.services,
+    dependencies: splitResult.dependencies,
+    layerDetails: splitResult.layerDetails,
+    databaseResult: splitResult.databaseResult,
+    modules: splitResult.modules,
+    methods: splitResult.methods,
+    moduleLevelDependencies: splitResult.moduleLevelDependencies,
+    methodLevelDependencies: splitResult.methodLevelDependencies,
+    fileAnalyses,
+    moduleDependencies,
+    entryPointFiles: new Set(findEntryPoints(fileAnalyses, moduleDependencies)),
+    metadata: {
+      totalFiles: files.length,
+      analyzedFiles: fileAnalyses.length,
+      branch: currentBranch || "HEAD",
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
 }
 
 // packages/core/dist/services/analysis-persistence.service.js
@@ -146282,7 +146368,7 @@ async function enrichFlowWithLLM(repoPath, flowId) {
 init_dist2();
 import { randomUUID as randomUUID5 } from "node:crypto";
 import fs9 from "node:fs";
-import path12 from "node:path";
+import path11 from "node:path";
 
 // packages/core/dist/services/rules.service.js
 init_dist2();
@@ -147184,7 +147270,7 @@ async function runViolationPipeline(input) {
   const enabledLlmCodeRules = enableLlmRules !== false ? allRules.filter((r) => (r.domain ? codeDomains.has(r.domain) : r.category === "code") && r.type === "llm" && r.prompt) : [];
   const archLlmRules = allRules.filter((r) => r.type === "llm" && r.prompt && r.domain === "architecture").map((r) => ({ key: r.key, name: r.name, severity: r.severity, prompt: r.prompt, category: r.category }));
   const dbSchemaLlmRules = allRules.filter((r) => r.type === "llm" && r.prompt && r.domain === "database" && r.category === "database").map((r) => ({ key: r.key, name: r.name, severity: r.severity, prompt: r.prompt, category: r.category }));
-  const filesToScan = changedFileSet ? [...changedFileSet].map((relPath) => ({ filePath: relPath, resolve: true })) : (result.fileAnalyses || []).map((fa) => ({ filePath: fa.filePath, resolve: !path12.isAbsolute(fa.filePath) }));
+  const filesToScan = changedFileSet ? [...changedFileSet].map((relPath) => ({ filePath: relPath, resolve: true })) : (result.fileAnalyses || []).map((fa) => ({ filePath: fa.filePath, resolve: !path11.isAbsolute(fa.filePath) }));
   const hasLlm = enabledLlm.length > 0;
   if (hasLlm)
     tracker?.start("scan", "Reading files...");
@@ -147196,7 +147282,7 @@ async function runViolationPipeline(input) {
       const lang = detectLanguage(filePath);
       if (!lang)
         continue;
-      const absPath = resolve7 ? path12.resolve(repoPath, filePath) : path12.isAbsolute(filePath) ? filePath : path12.join(repoPath, filePath);
+      const absPath = resolve7 ? path11.resolve(repoPath, filePath) : path11.isAbsolute(filePath) ? filePath : path11.join(repoPath, filePath);
       if (!fs9.existsSync(absPath))
         continue;
       const content = fs9.readFileSync(absPath, "utf-8");
@@ -147212,7 +147298,7 @@ async function runViolationPipeline(input) {
   let typeQuery;
   const enabledCodeKeys = new Set(enabledCodeRules.filter((r) => r.type === "deterministic" && r.enabled).map((r) => r.key));
   if (hasTypeAwareVisitors(enabledCodeKeys)) {
-    const tsFiles = filesToScan.filter(({ filePath: fp }) => /\.(ts|tsx|js|jsx)$/.test(fp)).map(({ filePath: fp, resolve: res }) => res ? path12.resolve(repoPath, fp) : path12.isAbsolute(fp) ? fp : path12.join(repoPath, fp));
+    const tsFiles = filesToScan.filter(({ filePath: fp }) => /\.(ts|tsx|js|jsx)$/.test(fp)).map(({ filePath: fp, resolve: res }) => res ? path11.resolve(repoPath, fp) : path11.isAbsolute(fp) ? fp : path11.join(repoPath, fp));
     if (tsFiles.length > 0) {
       const scoped = buildScopedCompilerOptions(repoPath);
       typeQuery = createTypeQueryService(tsFiles, scoped);
@@ -147291,7 +147377,7 @@ async function runViolationPipeline(input) {
         const lang = detectLanguage(filePath);
         if (!lang)
           continue;
-        const absPath = resolve7 ? path12.resolve(repoPath, filePath) : path12.isAbsolute(filePath) ? filePath : path12.join(repoPath, filePath);
+        const absPath = resolve7 ? path11.resolve(repoPath, filePath) : path11.isAbsolute(filePath) ? filePath : path11.join(repoPath, filePath);
         const key = changedFileSet ? absPath : filePath;
         const fc = fileContents.get(key);
         if (!fc)
@@ -147305,7 +147391,7 @@ async function runViolationPipeline(input) {
   }
   log.info(`[Pipeline] Code scan: ${allCodeViolations.length} violations from ${filesToScan.length} files (${enabledCodeRules.length} det rules, ${enabledLlmCodeRules.length} LLM rules)`);
   if (enabledCodeRules.some((r) => r.key === "bugs/deterministic/invalid-pyproject-toml")) {
-    const pyprojectPath = path12.join(repoPath, "pyproject.toml");
+    const pyprojectPath = path11.join(repoPath, "pyproject.toml");
     if (fs9.existsSync(pyprojectPath)) {
       try {
         const { checkPyprojectToml: checkPyprojectToml2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
@@ -148128,7 +148214,7 @@ function processLlmCodeViolations(codeResult, validFilePaths, fileContents, allC
   for (const v of codeResult.violations) {
     let filePath = v.filePath;
     if (!validFilePaths.has(filePath)) {
-      const resolved = path12.resolve(repoPath, filePath);
+      const resolved = path11.resolve(repoPath, filePath);
       if (validFilePaths.has(resolved)) {
         filePath = resolved;
       } else {
@@ -148222,116 +148308,153 @@ async function analyzeCore(project, options) {
     const start = Date.now();
     const effectiveCategories = options.enabledCategoriesOverride?.length ? options.enabledCategoriesOverride : projectConfig.enabledCategories ?? void 0;
     const effectiveLlmRules = projectConfig.enableLlmRules ?? options.enableLlmRulesOverride ?? true;
-    options.tracker?.start("parse", isDiff2 ? "Analyzing working tree..." : "Starting analysis...");
-    const result = await runAnalysis(project.path, branch ?? void 0, (progress) => {
-      options.tracker?.detail("parse", progress.detail ?? "Analyzing...");
-      options.onProgress?.({ detail: progress.detail });
-    }, { signal, skipStash: isDiff2 });
-    if (signal?.aborted) {
-      throw new DOMException(isDiff2 ? "Diff cancelled" : "Analysis cancelled", "AbortError");
-    }
-    const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
-    let changedFiles = [];
-    let changedFileSet;
-    if (isDiff2) {
+    let didStash = false;
+    let stashGit;
+    if (!isDiff2 && !skipGit && !options.skipStash) {
       try {
-        const git = await getGit(project.path);
-        const statusResult = await git.status();
-        for (const f2 of statusResult.not_added)
-          changedFiles.push({ path: f2, status: "new" });
-        for (const f2 of statusResult.created)
-          changedFiles.push({ path: f2, status: "new" });
-        for (const f2 of statusResult.modified)
-          changedFiles.push({ path: f2, status: "modified" });
-        for (const f2 of statusResult.staged) {
-          if (!changedFiles.some((cf) => cf.path === f2)) {
+        stashGit = await getGit(project.path);
+        const status = await stashGit.status();
+        if (!status.isClean()) {
+          const gitRoot = (await stashGit.revparse(["--show-toplevel"])).trim();
+          const isSubdirectory = path12.resolve(project.path) !== path12.resolve(gitRoot);
+          if (!isSubdirectory) {
+            options.tracker?.detail("parse", "Stashing pending changes...");
+            options.onProgress?.({ detail: "Stashing pending changes to analyze committed state..." });
+            const stashResult = await stashGit.stash([
+              "push",
+              "--include-untracked",
+              "-m",
+              "truecourse-analysis-stash"
+            ]);
+            didStash = !stashResult.includes("No local changes");
+          }
+        }
+      } catch (error) {
+        log.warn(`[Analyzer] Failed to stash changes, analyzing current state: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    try {
+      options.tracker?.start("parse", isDiff2 ? "Analyzing working tree..." : "Starting analysis...");
+      const result = await runAnalysis(project.path, branch ?? void 0, (progress) => {
+        options.tracker?.detail("parse", progress.detail ?? "Analyzing...");
+        options.onProgress?.({ detail: progress.detail });
+      }, { signal });
+      if (signal?.aborted) {
+        throw new DOMException(isDiff2 ? "Diff cancelled" : "Analysis cancelled", "AbortError");
+      }
+      const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
+      let changedFiles = [];
+      let changedFileSet;
+      if (isDiff2) {
+        try {
+          const git = await getGit(project.path);
+          const statusResult = await git.status();
+          for (const f2 of statusResult.not_added)
+            changedFiles.push({ path: f2, status: "new" });
+          for (const f2 of statusResult.created)
+            changedFiles.push({ path: f2, status: "new" });
+          for (const f2 of statusResult.modified)
             changedFiles.push({ path: f2, status: "modified" });
+          for (const f2 of statusResult.staged) {
+            if (!changedFiles.some((cf) => cf.path === f2)) {
+              changedFiles.push({ path: f2, status: "modified" });
+            }
           }
+          for (const f2 of statusResult.deleted)
+            changedFiles.push({ path: f2, status: "deleted" });
+        } catch (err) {
+          log.warn(`[Diff] git status failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else if (latestBaseline?.analysis.commitHash && !skipGit) {
+        try {
+          const git = await getGit(project.path);
+          const diffOutput = await git.diff([latestBaseline.analysis.commitHash, "HEAD", "--name-only"]);
+          const files = diffOutput.trim().split("\n").filter(Boolean);
+          if (files.length > 0)
+            changedFileSet = new Set(files);
+        } catch {
         }
-        for (const f2 of statusResult.deleted)
-          changedFiles.push({ path: f2, status: "deleted" });
-      } catch (err) {
-        log.warn(`[Diff] git status failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-    } else if (latestBaseline?.analysis.commitHash && !skipGit) {
-      try {
-        const git = await getGit(project.path);
-        const diffOutput = await git.diff([latestBaseline.analysis.commitHash, "HEAD", "--name-only"]);
-        const files = diffOutput.trim().split("\n").filter(Boolean);
-        if (files.length > 0)
-          changedFileSet = new Set(files);
-      } catch {
+      if (!isDiff2) {
+        try {
+          graph.flows = detectFlows(result);
+        } catch (flowError) {
+          log.error(`[Flows] Detection failed: ${flowError instanceof Error ? flowError.message : String(flowError)}`);
+          graph.flows = [];
+        }
+        touchProject(project.slug);
+      }
+      options.tracker?.done("parse", `${result.services.length} services, ${result.fileAnalyses?.length ?? 0} files`);
+      const previousActiveViolations = latestBaseline ? latestBaseline.violations.filter((v) => branch == null || latestBaseline.analysis.branch == null || latestBaseline.analysis.branch === branch) : [];
+      const previousAnalysisId = latestBaseline?.analysis.id ?? null;
+      const provider = options.provider ?? (effectiveLlmRules ? createLLMProvider() : void 0);
+      if (provider) {
+        provider.setAnalysisId(analysisId);
+        provider.setRepoPath(project.path);
+        if (signal)
+          provider.setAbortSignal(signal);
+      }
+      const pipelineResult = await runViolationPipeline({
+        repoPath: project.path,
+        analysisId,
+        now,
+        result,
+        serviceIdMap,
+        moduleIdMap,
+        methodIdMap,
+        dbIdMap,
+        previousActiveViolations,
+        changedFileSet,
+        tracker: options.tracker,
+        enabledCategories: effectiveCategories,
+        enableLlmRules: effectiveLlmRules,
+        provider,
+        signal,
+        onLlmEstimate: options.onLlmEstimate ? async (estimate) => {
+          const proceed = await options.onLlmEstimate(estimate);
+          options.onLlmResolved?.(proceed);
+          return proceed;
+        } : void 0
+      });
+      if (pipelineResult.serviceDescriptions.length > 0) {
+        for (const desc of pipelineResult.serviceDescriptions) {
+          const svc = graph.services.find((s) => s.id === desc.id);
+          if (svc)
+            svc.description = desc.description;
+        }
+      }
+      const usage = provider ? toUsageRecords(provider.flushUsage()) : [];
+      enforceLocationInvariant(pipelineResult.added);
+      enforceLocationInvariant(pipelineResult.unchanged);
+      enforceLocationInvariant(pipelineResult.resolved);
+      log.info(`[${isDiff2 ? "Diff" : "Analysis"}] core complete in ${Date.now() - start}ms \u2014 ${pipelineResult.added.length} added, ${pipelineResult.unchanged.length} unchanged, ${pipelineResult.resolvedRefs.length} resolved`);
+      return {
+        mode,
+        analysisId,
+        now,
+        branch,
+        commitHash,
+        architecture: result.architecture,
+        metadata: result.metadata ?? null,
+        graph,
+        changedFiles,
+        pipelineResult,
+        usage,
+        latestBaseline,
+        previousAnalysisId,
+        analysisResult: result
+      };
+    } finally {
+      if (didStash && stashGit) {
+        options.tracker?.detail("parse", "Restoring pending changes...");
+        options.onProgress?.({ detail: "Restoring pending changes..." });
+        try {
+          await stashGit.stash(["pop"]);
+        } catch (error) {
+          log.error(`[Analyzer] Failed to restore stashed changes. Run "git stash pop" manually. ${error instanceof Error ? error.message : String(error)}`);
+        }
       }
     }
-    if (!isDiff2) {
-      try {
-        graph.flows = detectFlows(result);
-      } catch (flowError) {
-        log.error(`[Flows] Detection failed: ${flowError instanceof Error ? flowError.message : String(flowError)}`);
-        graph.flows = [];
-      }
-      touchProject(project.slug);
-    }
-    options.tracker?.done("parse", `${result.services.length} services, ${result.fileAnalyses?.length ?? 0} files`);
-    const previousActiveViolations = latestBaseline ? latestBaseline.violations.filter((v) => branch == null || latestBaseline.analysis.branch == null || latestBaseline.analysis.branch === branch) : [];
-    const previousAnalysisId = latestBaseline?.analysis.id ?? null;
-    const provider = options.provider ?? (effectiveLlmRules ? createLLMProvider() : void 0);
-    if (provider) {
-      provider.setAnalysisId(analysisId);
-      provider.setRepoPath(project.path);
-      if (signal)
-        provider.setAbortSignal(signal);
-    }
-    const pipelineResult = await runViolationPipeline({
-      repoPath: project.path,
-      analysisId,
-      now,
-      result,
-      serviceIdMap,
-      moduleIdMap,
-      methodIdMap,
-      dbIdMap,
-      previousActiveViolations,
-      changedFileSet,
-      tracker: options.tracker,
-      enabledCategories: effectiveCategories,
-      enableLlmRules: effectiveLlmRules,
-      provider,
-      signal,
-      onLlmEstimate: options.onLlmEstimate ? async (estimate) => {
-        const proceed = await options.onLlmEstimate(estimate);
-        options.onLlmResolved?.(proceed);
-        return proceed;
-      } : void 0
-    });
-    if (pipelineResult.serviceDescriptions.length > 0) {
-      for (const desc of pipelineResult.serviceDescriptions) {
-        const svc = graph.services.find((s) => s.id === desc.id);
-        if (svc)
-          svc.description = desc.description;
-      }
-    }
-    const usage = provider ? toUsageRecords(provider.flushUsage()) : [];
-    enforceLocationInvariant(pipelineResult.added);
-    enforceLocationInvariant(pipelineResult.unchanged);
-    enforceLocationInvariant(pipelineResult.resolved);
-    log.info(`[${isDiff2 ? "Diff" : "Analysis"}] core complete in ${Date.now() - start}ms \u2014 ${pipelineResult.added.length} added, ${pipelineResult.unchanged.length} unchanged, ${pipelineResult.resolvedRefs.length} resolved`);
-    return {
-      mode,
-      analysisId,
-      now,
-      branch,
-      commitHash,
-      architecture: result.architecture,
-      metadata: result.metadata ?? null,
-      graph,
-      changedFiles,
-      pipelineResult,
-      usage,
-      latestBaseline,
-      previousAnalysisId,
-      analysisResult: result
-    };
   } finally {
     releaseAnalyzeLock(project.path);
   }
@@ -152743,7 +152866,28 @@ router2.delete("/:id/analyses/:analysisId", async (req, res, next) => {
     next(error);
   }
 });
+async function resolveStashDecisionForRoute(repoId, repoPath) {
+  let modifiedCount = 0;
+  let untrackedCount = 0;
+  try {
+    const git = await getGit(repoPath);
+    const status = await git.status();
+    if (status.isClean()) return "stash";
+    const gitRoot = (await git.revparse(["--show-toplevel"])).trim();
+    if (path15.resolve(repoPath) !== path15.resolve(gitRoot)) return "stash";
+    modifiedCount = status.modified.length + status.staged.length + status.deleted.length + status.created.length;
+    untrackedCount = status.not_added.length;
+  } catch {
+    return "stash";
+  }
+  return createSocketStashConfirmHandler(repoId)({ modifiedCount, untrackedCount });
+}
 async function runFullAnalyze(id, repo, opts) {
+  const stashDecision = await resolveStashDecisionForRoute(id, repo.path);
+  if (stashDecision === "cancel") {
+    emitAnalysisCanceled(id);
+    return;
+  }
   const provider = opts.effectiveLlmRules ? createLLMProvider() : void 0;
   if (provider) {
     provider.setRepoId(id);
@@ -152752,6 +152896,7 @@ async function runFullAnalyze(id, repo, opts) {
   }
   const outcome = await analyzeInProcess(repo, {
     skipGit: opts.skipGit,
+    skipStash: stashDecision === "no-stash",
     enabledCategoriesOverride: opts.effectiveCategories,
     enableLlmRulesOverride: opts.effectiveLlmRules,
     tracker: opts.tracker,