truecourse 0.5.6 → 0.5.7

package/cli.mjs

@@ -10586,7 +10586,72 @@ var init_language_config = __esm({
 
 // packages/analyzer/dist/file-discovery.js
 import { existsSync as existsSync2, readFileSync, readdirSync as readdirSync2, statSync } from "fs";
+import { execFileSync } from "child_process";
 import { join, relative, resolve as resolve2 } 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 p2 of getAllTestPatterns())
+    ig.add(p2);
+  for (const p2 of getAllIgnorePatterns())
+    ig.add(p2);
+  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 = statSync(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 = resolve2(startDir);
@@ -10596,25 +10661,46 @@ function findAllGitignores(startDir) {
       gitignores.unshift({ path: gitignorePath, dir: currentDir });
     }
     const parentDir = resolve2(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())
@@ -10623,7 +10709,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) {
@@ -10634,23 +10720,27 @@ function discoverFiles(dir) {
         const relativePath = relative(rootDir, fullPath);
         const stat = statSync(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"() {
@@ -93831,7 +93921,6 @@ var init_dist6 = __esm({
 });
 
 // packages/core/dist/services/analyzer.service.js
-import path11 from "node:path";
 function runDeterministicModuleChecks(result, enabledDeterministic) {
   if (!result.modules || !result.methods)
     return [];
@@ -93864,150 +93953,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_dist6(), dist_exports2));
+  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_dist6(), dist_exports2));
-    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;
-        }
-      }
-    }
-    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);
-          }
+          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()
+    }
+  };
 }
 var init_analyzer_service = __esm({
   "packages/core/dist/services/analyzer.service.js"() {
@@ -101346,14 +101407,14 @@ var require_main = __commonJS({
 });
 
 // packages/core/dist/config/env.js
-import path12 from "node:path";
+import path11 from "node:path";
 import os3 from "node:os";
 var import_dotenv;
 var init_env = __esm({
   "packages/core/dist/config/env.js"() {
     "use strict";
     import_dotenv = __toESM(require_main(), 1);
-    import_dotenv.default.config({ path: path12.join(os3.homedir(), ".truecourse", ".env") });
+    import_dotenv.default.config({ path: path11.join(os3.homedir(), ".truecourse", ".env") });
     import_dotenv.default.config({ path: "../../.env" });
   }
 });
@@ -103546,7 +103607,7 @@ var init_violation_lifecycle_service = __esm({
 // packages/core/dist/services/violation-pipeline.service.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import fs9 from "node:fs";
-import path13 from "node:path";
+import path12 from "node:path";
 function throwIfAborted(signal) {
   if (signal?.aborted)
     throw new DOMException("Analysis cancelled", "AbortError");
@@ -103649,7 +103710,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: !path13.isAbsolute(fa.filePath) }));
+  const filesToScan = changedFileSet ? [...changedFileSet].map((relPath) => ({ filePath: relPath, resolve: true })) : (result.fileAnalyses || []).map((fa) => ({ filePath: fa.filePath, resolve: !path12.isAbsolute(fa.filePath) }));
   const hasLlm = enabledLlm.length > 0;
   if (hasLlm)
     tracker?.start("scan", "Reading files...");
@@ -103661,7 +103722,7 @@ async function runViolationPipeline(input) {
       const lang = detectLanguage(filePath);
       if (!lang)
         continue;
-      const absPath = resolve8 ? path13.resolve(repoPath, filePath) : path13.isAbsolute(filePath) ? filePath : path13.join(repoPath, filePath);
+      const absPath = resolve8 ? path12.resolve(repoPath, filePath) : path12.isAbsolute(filePath) ? filePath : path12.join(repoPath, filePath);
       if (!fs9.existsSync(absPath))
         continue;
       const content = fs9.readFileSync(absPath, "utf-8");
@@ -103677,7 +103738,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 ? path13.resolve(repoPath, fp) : path13.isAbsolute(fp) ? fp : path13.join(repoPath, fp));
+    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));
     if (tsFiles.length > 0) {
       const scoped = buildScopedCompilerOptions(repoPath);
       typeQuery = createTypeQueryService(tsFiles, scoped);
@@ -103756,7 +103817,7 @@ async function runViolationPipeline(input) {
         const lang = detectLanguage(filePath);
         if (!lang)
           continue;
-        const absPath = resolve8 ? path13.resolve(repoPath, filePath) : path13.isAbsolute(filePath) ? filePath : path13.join(repoPath, filePath);
+        const absPath = resolve8 ? path12.resolve(repoPath, filePath) : path12.isAbsolute(filePath) ? filePath : path12.join(repoPath, filePath);
         const key = changedFileSet ? absPath : filePath;
         const fc = fileContents.get(key);
         if (!fc)
@@ -103770,7 +103831,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 = path13.join(repoPath, "pyproject.toml");
+    const pyprojectPath = path12.join(repoPath, "pyproject.toml");
     if (fs9.existsSync(pyprojectPath)) {
       try {
         const { checkPyprojectToml: checkPyprojectToml2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports2));
@@ -104593,7 +104654,7 @@ function processLlmCodeViolations(codeResult, validFilePaths, fileContents, allC
   for (const v of codeResult.violations) {
     let filePath = v.filePath;
     if (!validFilePaths.has(filePath)) {
-      const resolved = path13.resolve(repoPath, filePath);
+      const resolved = path12.resolve(repoPath, filePath);
       if (validFilePaths.has(resolved)) {
         filePath = resolved;
       } else {
@@ -104663,6 +104724,7 @@ var init_usage_service = __esm({
 
 // packages/core/dist/commands/analyze-core.js
 import { randomUUID as randomUUID6 } from "node:crypto";
+import path13 from "node:path";
 async function analyzeCore(project, options) {
   try {
     acquireAnalyzeLock(project.path);
@@ -104704,116 +104766,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", isDiff ? "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: isDiff });
-    if (signal?.aborted) {
-      throw new DOMException(isDiff ? "Diff cancelled" : "Analysis cancelled", "AbortError");
-    }
-    const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
-    let changedFiles = [];
-    let changedFileSet;
-    if (isDiff) {
+    let didStash = false;
+    let stashGit;
+    if (!isDiff && !skipGit && !options.skipStash) {
       try {
-        const git = await getGit(project.path);
-        const statusResult = await git.status();
-        for (const f of statusResult.not_added)
-          changedFiles.push({ path: f, status: "new" });
-        for (const f of statusResult.created)
-          changedFiles.push({ path: f, status: "new" });
-        for (const f of statusResult.modified)
-          changedFiles.push({ path: f, status: "modified" });
-        for (const f of statusResult.staged) {
-          if (!changedFiles.some((cf) => cf.path === f)) {
+        stashGit = await getGit(project.path);
+        const status = await stashGit.status();
+        if (!status.isClean()) {
+          const gitRoot = (await stashGit.revparse(["--show-toplevel"])).trim();
+          const isSubdirectory = path13.resolve(project.path) !== path13.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", isDiff ? "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(isDiff ? "Diff cancelled" : "Analysis cancelled", "AbortError");
+      }
+      const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
+      let changedFiles = [];
+      let changedFileSet;
+      if (isDiff) {
+        try {
+          const git = await getGit(project.path);
+          const statusResult = await git.status();
+          for (const f of statusResult.not_added)
+            changedFiles.push({ path: f, status: "new" });
+          for (const f of statusResult.created)
+            changedFiles.push({ path: f, status: "new" });
+          for (const f of statusResult.modified)
             changedFiles.push({ path: f, status: "modified" });
+          for (const f of statusResult.staged) {
+            if (!changedFiles.some((cf) => cf.path === f)) {
+              changedFiles.push({ path: f, status: "modified" });
+            }
           }
+          for (const f of statusResult.deleted)
+            changedFiles.push({ path: f, 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 f of statusResult.deleted)
-          changedFiles.push({ path: f, 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 (!isDiff) {
+        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(`[${isDiff ? "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 (!isDiff) {
-      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(`[${isDiff ? "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);
   }
@@ -105134,6 +105233,7 @@ init_progress();
 init_paths();
 init_registry();
 init_project_config();
+init_git();
 init_logger();
 init_helpers();
 
@@ -105311,6 +105411,50 @@ function resolveLlmDecision(options, configDefault) {
   }
   return { enabled: configDefault, autoApproveEstimate: false };
 }
+async function resolveStashDecision(options, repoPath) {
+  if (options.stash === true) return { skipStash: false };
+  if (options.stash === false) return { skipStash: true };
+  let modifiedCount = 0;
+  let untrackedCount = 0;
+  try {
+    const git = await getGit(repoPath);
+    const status = await git.status();
+    if (status.isClean()) return { skipStash: false };
+    modifiedCount = status.modified.length + status.staged.length + status.deleted.length + status.created.length;
+    untrackedCount = status.not_added.length;
+  } catch {
+    return { skipStash: false };
+  }
+  if (!isInteractive()) {
+    exitMissingNonInteractiveFlag(
+      "analyze needs a decision on stashing before running non-interactively.",
+      "Pass --stash to stash pending changes (analyze committed state) or --no-stash to analyze the working tree as-is."
+    );
+  }
+  O2.warn(
+    `Your repository has ${modifiedCount} modified and ${untrackedCount} untracked file(s).`
+  );
+  const choice = await _t({
+    message: "How should TrueCourse handle them?",
+    options: [
+      {
+        value: "stash",
+        label: "Stash and analyze committed state (recommended)",
+        hint: "changes are temporarily stashed and restored after the run"
+      },
+      {
+        value: "no-stash",
+        label: "Don't stash \u2014 analyze the working tree as-is",
+        hint: "uncommitted changes are included in the analysis"
+      }
+    ]
+  });
+  if (q(choice)) {
+    pt("Cancelled \u2014 no changes made");
+    process.exit(0);
+  }
+  return { skipStash: choice === "no-stash" };
+}
 async function runAnalyze(options = {}) {
   mt("Analyzing repository");
   ensureClaudeCli();
@@ -105325,6 +105469,7 @@ async function runAnalyze(options = {}) {
   const enabledCategories = config2.enabledCategories ?? void 0;
   const llmDecision = resolveLlmDecision(options, config2.enableLlmRules ?? true);
   const enableLlmRules = llmDecision.enabled;
+  const stashDecision = await resolveStashDecision(options, project.path);
   renderPhase = enableLlmRules ? "pre-llm" : "all";
   if (wipeLegacyPostgresData()) {
     O2.info("Legacy Postgres data wiped. Re-analyze to repopulate.");
@@ -105340,6 +105485,7 @@ async function runAnalyze(options = {}) {
     const result = await analyzeInProcess(project, {
       tracker,
       signal: abortController.signal,
+      skipStash: stashDecision.skipStash,
       enabledCategoriesOverride: enabledCategories,
       enableLlmRulesOverride: enableLlmRules,
       onLlmEstimate: async (estimate) => {
@@ -109221,7 +109367,7 @@ async function runHooksRun() {
 
 // tools/cli/src/index.ts
 var program2 = new Command();
-program2.name("truecourse").version("0.5.6").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
+program2.name("truecourse").version("0.5.7").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
 var dashboardCmd = program2.command("dashboard").description("Start the TrueCourse dashboard and open it in your browser").option("--reconfigure", "Re-prompt for console vs background service mode").option("--service", "Run as a background service (skips mode prompt)").option("--console", "Run in this terminal (skips mode prompt)").action(async (options) => {
   if (options.service && options.console) {
     console.error("error: --service and --console are mutually exclusive");
@@ -109247,13 +109393,14 @@ function resolveInstallSkills(options) {
   if (options.skills === false) return false;
   return void 0;
 }
-program2.command("analyze").description("Analyze the current repository").option("--diff", "Run diff check against latest analysis").option("--llm", "Run LLM-powered rules (pre-approves the cost estimate)").option("--no-llm", "Skip LLM-powered rules for this run").option("--install-skills", "Install Claude Code skills without prompting").option("--no-skills", "Skip the Claude Code skills prompt").action(async (options) => {
+program2.command("analyze").description("Analyze the current repository").option("--diff", "Run diff check against latest analysis").option("--llm", "Run LLM-powered rules (pre-approves the cost estimate)").option("--no-llm", "Skip LLM-powered rules for this run").option("--stash", "Pre-approve stashing pending changes before analysis").option("--no-stash", "Analyze the working tree as-is without stashing").option("--install-skills", "Install Claude Code skills without prompting").option("--no-skills", "Skip the Claude Code skills prompt").action(async (options) => {
   const llm = typeof options.llm === "boolean" ? options.llm : void 0;
+  const stash = typeof options.stash === "boolean" ? options.stash : void 0;
   const installSkills = resolveInstallSkills(options);
   if (options.diff) {
-    await runAnalyzeDiff({ llm, installSkills });
+    await runAnalyzeDiff({ llm, stash, installSkills });
   } else {
-    await runAnalyze({ llm, installSkills });
+    await runAnalyze({ llm, stash, installSkills });
   }
 });
 program2.command("add").description("Register the current directory with TrueCourse").option("--install-skills", "Install Claude Code skills without prompting").option("--no-skills", "Skip the Claude Code skills prompt").action(async (options) => {