dsh-arcvista 0.1.5 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.0 - 2026-11-02
+
+- Release 0.2.0.
+
+## 0.1.6 - 2026-11-02
+
+- Release 0.1.6.
+
 ## 0.1.5 - 2026-11-02
 
 - Release 0.1.5.

package/README.md

@@ -1,8 +1,8 @@
 # ArcVista · 观界
 
-本地优先的架构观测台：接入一个 Git 仓库，自动生成**可下钻的系统架构图、安全架构守护清单、业务知识图谱、复杂度与测试覆盖度**，并支持**对比不同分支之间的架构漂移与风险**。
+本地优先的架构观测台：选择一个本地项目目录，自动生成**可下钻的系统架构图、安全架构守护清单、业务知识图谱、复杂度与测试覆盖度**，并支持**对比不同快照之间的架构漂移与风险**。
 
-零第三方依赖，只用 Node 22 内置的 `node:http` + `node:sqlite`，数据保存在本机 SQLite；内置 6 套可切换皮肤。
+零第三方依赖，只用 Node 22 内置的 `node:http` 与本地 JSON 文件；项目列表在插件数据目录，分析产出在项目自己的 `.arcvista/` 目录。内置 6 套可切换皮肤。
 
 ![系统架构图](docs/screenshots/architecture.png)
 
@@ -13,7 +13,7 @@
 1. 这个系统现在**长什么样**（分层、边界、服务之间的真实调用与数据依赖）；
 2. 它有哪些**架构守护**（认证、授权、注入防护、扫描规则、CI 门禁），这些规则是否可追溯；
 3. 它的**业务知识**如何组织（业务域、能力、实体、事件、主流程）；
-4. 换一个分支之后，架构、守护规则、依赖、复杂度和覆盖率**发生了什么变化，是否存在风险**。
+4. 重新分析当前工作区之后，架构、守护规则、依赖、复杂度和覆盖率**发生了什么变化，是否存在风险**。
 
 ArcVista 把这些问题做成一个可以直接下钻的看板，而不是一堆静态报告。
 
@@ -25,7 +25,7 @@ ArcVista 把这些问题做成一个可以直接下钻的看板，而不是一
 
 - **不需要单独启动 Node 服务**：ArcVista 的 API 和静态页面由 DSH Host 插件直接挂载在 `/arcvista` 路径下；
 - **不需要配置模型**：分析使用 DSH 当前选择的默认模型（例如 `deepseek-flash`），模型调用通过 DSH 的 `llm` 服务完成；设置页不提供模型配置；
-- 数据仍保存在本机：默认写在 `~/.dsh/arcvista/`（SQLite、备份和仓库镜像），不会写进 `node_modules`；
+- 数据仍保存在本机：项目列表、任务与设置写在 `~/.dsh/arcvista/`；分析快照写在每个项目的 `.arcvista/`；
 - 面板顶部显示运行状态，右上角可以刷新或在独立浏览器窗口打开；
 - 主题跟随 DSH 的浅色 / 深色模式（映射到 `daylight` / `obsidian`），内嵌页面隐藏了 ArcVista 原来的左侧栏；
 - 插件随 DSH 启动而加载，无需手动维护端口或进程。
@@ -88,8 +88,8 @@ npm run package:security-review
 
 这个插件会在 DSH Host 进程里执行以下操作，安装前请确认：
 
-- 用 `git` 克隆 / 拉取被观测仓库，读取工作区文件，生成静态分析结果；
-- 在 DSH profile 的 `arcvista/` 下写 SQLite、备份和任务状态；
+- 读取用户选择的本地项目目录（只读源码）；如果目录是 Git 仓库，会调用本机 `git` 读取当前分支、提交与变更热度；
+- 在全局插件目录 `~/.dsh/arcvista/` 写项目列表、任务与设置；在项目内 `.arcvista/` 写分析快照与下钻缓存；
 - 通过 DSH 的 `llm` 服务调用当前默认模型做语义增强；
 - 在 DSH Web 服务器注册 `/arcvista` 路由，用于面板和 API。
 
@@ -97,22 +97,22 @@ npm run package:security-review
 
 ## 快速开始
 
-要求：Node.js **>= 22.5**（使用内置 `node:sqlite`），本机安装 `git`。
+要求：Node.js **>= 22.19**，本机安装 `git`（可选；非 Git 目录也能分析）。
 
 ```bash
 cd arc-vista
 npm start
 ```
 
-打开 <http://127.0.0.1:4321>，点击「新建观测目标」，填入：
+打开 <http://127.0.0.1:4321>，点击「新建本地项目」，填入：
 
-- 产品名称；
-- Git 仓库地址（支持 `https://` / `ssh://` / `git@` / 本地绝对路径）；
-- 可选分支与描述。
+- 产品名称（可留空，默认取目录名）；
+- 本地项目目录的绝对路径；DSH 插件里也可以直接从已登记的工作区选择；
+- 可选描述。
 
-创建后会先在后台克隆 / 拉取仓库，完成后进入产品的「分支分析清单」：勾选要分析的分支（可多选）后开始分析，任务会按队列依次执行，全部分析完成后进入看板。
+创建后会立即分析当前工作区，不需要克隆、拉取或手动准备仓库。分析产出写入项目内的 `.arcvista/`。
 
-> 不需要 `npm install`：项目没有任何运行时依赖。第一次分析需要能访问仓库地址。
+> 不需要 `npm install`：项目没有任何运行时依赖。
 
 ## 皮肤
 
@@ -133,21 +133,18 @@ npm start
 
 ## 功能
 
-### 0. 仓库准备与分支分析清单
+### 0. 本地项目接入
 
-![分支分析清单](docs/screenshots/branch-analysis.png)
-
-- 新建产品后先显示克隆 / 拉取进度，完成后自动刷新出分支清单；
-- 每个分支显示最新提交、是否已分析、分析中 / 排队中 / 上次失败等状态；
-- 可勾选多个未分析分支批量开始，任务按队列依次执行；
-- 已分析分支可以直接「查看看板」或「重新分析」；
-- 全部分析完成后自动进入看板，也可以随时从看板右上角「分析分支」打开清单。
+- 新建项目时填写本地目录绝对路径，DSH 插件模式下可以直接选择已登记的工作区；
+- 创建后立即分析当前工作区，不克隆、不拉取、不切换分支；
+- 可以随时重新分析，生成新的快照；
+- 项目列表、任务与设置保存在全局插件目录，分析产出保存在项目自己的 `.arcvista/`。
 
 ### 1. 系统架构图（可下钻）
 
 ![节点详情](docs/screenshots/architecture-node.png)
 
-- 由仓库结构、构建清单、网关路由、Feign 声明、编排配置与依赖推断生成的分层架构图：客户端 → 接入层 → 服务层 → 数据层 → 基础设施 / 外部系统。
+- 由项目结构、构建清单、网关路由、Feign 声明、编排配置与依赖推断生成的分层架构图：客户端 → 接入层 → 服务层 → 数据层 → 基础设施 / 外部系统。
 - 拖拽平移、滚轮缩放、节点悬停高亮依赖链路；点击节点打开节点详情（指标、复杂度驱动、上下游依赖、下钻入口）。
 - **下钻分析**：进入单个模块的内部结构（按 Controller / Service / Domain / DTO / 事件 / 配置等职责聚合的依赖子图）、关键流程、对外接口、调用方/被依赖方、数据组件、模块风险与改进建议；支持继续追问该模块。
 - 模型由 DSH 统一提供，架构的命名、业务职责、外部系统与连接会基于代码证据做语义增强；没有模型时启发式结果同样完整可用。
@@ -159,7 +156,7 @@ npm start
 - 19 类守护族：身份认证、授权/RBAC、输入校验、注入防护、传输加密、CORS、CSRF、限流、SAST、依赖扫描、密钥扫描、硬编码密钥、审计日志、依赖锁定、容器安全、安全响应头、安全测试等。
 - 每项守护给出 `enforced / partial / missing` 状态、规则清单、证据文件与行号、改进建议。
 - 解析 `semgrep`、ESLint 安全规则、CodeQL、SonarQube、gitleaks、Dependabot、Renovate、Snyk、Trivy、Dockerfile、lockfile、Spring Security / JWT / MyBatis / helmet / express-rate-limit 等真实配置。
-- 规则清单是**可 diff 的**：分支对比会逐条列出新增和移除的规则。
+- 规则清单是**可 diff 的**：快照对比会逐条列出新增和移除的规则。
 
 ### 3. 业务知识图谱
 
@@ -182,9 +179,9 @@ npm start
 - 没有产物时使用明确标注的**估算值**（测试/源码 LOC 比、测试文件比、用例数、零测试模块），并在界面和风险条目中说明局限。
 - 展示测试用例数、测试文件、模块覆盖、未覆盖模块与大文件、测试缺口清单。
 
-### 6. 分支对比与风险判断
+### 6. 快照对比与风险判断
 
-![分支对比](docs/screenshots/branch-compare.png)
+![快照对比](docs/screenshots/branch-compare.png)
 
 选择任意两个快照（通常来自两个分支）进行对比：
 
@@ -207,43 +204,38 @@ npm start
 ## 工作方式
 
 ```
-Git 仓库 ──► 本地镜像（bare）──► 按提交检出 worktree
-                                      │
-        ┌─────────────────────────────┼──────────────────────────────┐
-        ▼                             ▼                              ▼
-   文件/模块/依赖图            安全守护扫描                    覆盖率产物解析
-        │                             │                              │
-        ├──────────────┬──────────────┴──────────────┬───────────────┤
-        ▼              ▼                             ▼               ▼
-   架构模型        知识图谱                      复杂度          风险规则
-        └──────────────┴──────────► 可选 LLM 语义增强 ◄─────────────┘
+本地项目目录（当前工作区）
+        │
+        ├── 文件 / 模块 / 依赖图 ──► 安全守护扫描 ──► 覆盖率产物解析
+        │                                  │
+        ├──────────────┬───────────────────┴──────────────┬───────────────┐
+        ▼              ▼                                  ▼               ▼
+   架构模型        知识图谱                           复杂度          风险规则
+        └──────────────┴──────────────► 可选 DSH 模型语义增强 ◄────────────┘
                                       │
                                       ▼
-                            快照（SQLite）+ 分支 diff
+                  <project>/.arcvista/snapshots/<id>.json
 ```
 
-- 仓库以 bare mirror 形式缓存在 `data/repos/`，按提交创建临时 worktree，分析完成后只保留最近用到的 worktree；**不会修改你的仓库**。
+- ArcVista **不克隆、不拉取、不切换分支**；分析的是你选择的本地目录当前内容。
+- 如果目录是 Git 仓库，会记录当前分支、提交与文件变更热度；非 Git 目录按“工作区”记录。
 - 每次分析生成一个不可变快照，包含完整分析 JSON、指标摘要、提交信息与引擎信息。
-- 分支对比基于快照计算，不依赖实时重分析。
-
-## Git 超时与断点续传
-
-大仓库首次克隆可能很慢。克隆、拉取与检出遇到**超时或网络错误会自动重试**（默认共 4 次，退避等待 2s / 4s / 6s）：
-
-- 克隆中断时会保留已经下载的数据，下一次尝试自动改为 `git fetch` **断点续传**，而不是从头再克隆；
-- 记录每次重试的原因与次数，可在任务日志中看到（"克隆失败（操作超时），2.0s 后自动重试（第 2/4 次）"）；
-- 网络长时间不可用导致最终失败时，任务卡片会提示可点「重试分析」继续续传，已下载的镜像不会丢弃；
-- 克隆、拉取、检出的超时时间与重试次数都可以用下方环境变量调整，例如大仓库可以调大 `ARCVISTA_GIT_CLONE_TIMEOUT_MS`。
+- 快照对比基于保存的快照计算；重新分析当前工作区即可生成新快照。
 
 ## 数据、备份与隐私
 
-- DSH 插件模式下，所有数据保存在 `~/.dsh/arcvista/arcvista.db`（SQLite）；独立 CLI 模式使用 `data/`。
-- 仓库镜像与检出代码在数据目录的 `repos/`、`worktrees/`，可随时删除，重新分析会重建。
-- **自动备份**：启动时、每次分析完成以及删除产品前，会把 SQLite 快照写入数据目录的 `backups/`（默认保留 12 份，文件权限 600；可用 `ARCVISTA_BACKUP_DIR` 修改位置，`ARCVISTA_BACKUP_KEEP` 修改保留数量）。
-- **自动恢复**：如果数据目录里的 `arcvista.db` 缺失或无法打开，启动时会自动从最近一份包含产品的备份恢复，并在启动日志和设置页提示恢复来源。
-- 设置页「当前状态」可以看到数据目录、备份目录和最近备份时间，也可以点「立即备份数据」手动备份。
-- 仓库镜像体积可能较大；备份只包含数据库（产品、快照、设置），不会重复备份仓库镜像。
-- 模型调用通过 DSH 的 `llm` 服务完成，ArcVista 不保存 API Key；分析时只把**仓库证据摘要**（模块、依赖、路由、配置、指标等，不含完整源码）发送给 DSH 当前模型。
+- 全局项目列表、任务和设置保存在 `~/.dsh/arcvista/`：
+  - `projects.json`：项目列表与本地目录；
+  - `jobs.json`：分析任务与日志；
+  - `settings.json`：本地设置；
+  - `backups/`：全局 JSON 备份。
+- 每个项目的分析产出保存在该项目的 `.arcvista/`：
+  - `snapshots/`：完整分析快照与索引；
+  - `drill/`：模块下钻缓存；
+  - `project.json`：ArcVista 项目标记。
+- 这些文件只在本机，不会写进 `node_modules`，也不会被 ArcVista 的文件扫描计入分析。
+- **备份**：每次分析完成、删除项目前以及手动点击「立即备份数据」时，会把全局项目列表、任务与设置写入 `backups/`（默认保留 12 份，权限 600）。
+- 模型调用通过 DSH 的 `llm` 服务完成，ArcVista 不保存 API Key；分析时只把**项目证据摘要**（模块、依赖、路由、配置、指标等，不含完整源码）发送给 DSH 当前模型。
 
 ## 环境变量
 
@@ -254,12 +246,6 @@ Git 仓库 ──► 本地镜像（bare）──► 按提交检出 worktree
 | `ARCVISTA_DATA` | `./data` | 数据目录 |
 | `ARCVISTA_BACKUP_DIR` | `./backups`（data 的同级目录） | 数据库自动备份目录 |
 | `ARCVISTA_BACKUP_KEEP` | `12` | 备份保留份数 |
-| `ARCVISTA_NO_AUTO_RESTORE` | — | 设为 `1` 时禁止数据库缺失时自动恢复 |
-| `ARCVISTA_GIT_RETRIES` | `4` | 克隆/拉取/检出失败时的总尝试次数 |
-| `ARCVISTA_GIT_RETRY_DELAY_MS` | `2000` | Git 重试的基础退避时间（毫秒） |
-| `ARCVISTA_GIT_CLONE_TIMEOUT_MS` | `900000` | 单次克隆超时（默认 15 分钟） |
-| `ARCVISTA_GIT_FETCH_TIMEOUT_MS` | `300000` | 单次拉取超时（默认 5 分钟） |
-| `ARCVISTA_GIT_WORKTREE_TIMEOUT_MS` | `300000` | 单次检出超时（默认 5 分钟） |
 | `ARCVISTA_DEBUG` | — | 打印异常堆栈 |
 
 ## API 一览
@@ -267,12 +253,13 @@ Git 仓库 ──► 本地镜像（bare）──► 按提交检出 worktree
 | 方法 | 路径 | 说明 |
 | --- | --- | --- |
 | `GET` | `/api/products` | 产品列表（含最新快照与任务状态） |
-| `POST` | `/api/products` | 创建产品并自动开始分析 |
-| `GET` | `/api/products/:id` | 产品详情、快照、分支、任务 |
-| `POST` | `/api/products/:id/analyze` | 分析分支（`branch`、`force`） |
+| `GET` | `/api/workspaces` | 可选的 DSH 工作区列表（插件模式） |
+| `POST` | `/api/products` | 创建本地项目并分析当前工作区 |
+| `GET` | `/api/products/:id` | 项目详情、快照、当前分支、任务 |
+| `POST` | `/api/products/:id/analyze` | 重新分析当前工作区（`force`） |
 | `GET` | `/api/products/:id/snapshots/:sid` | 快照完整分析结果 |
 | `POST` | `/api/products/:id/modules/analyze` | 模块下钻（异步任务） |
-| `GET` | `/api/products/:id/compare` | 分支/快照对比 |
+| `GET` | `/api/products/:id/compare` | 快照对比 |
 | `GET` | `/api/jobs/:id` | 任务进度与日志 |
 
 ## 目录结构
@@ -296,10 +283,10 @@ arcvista/
 │   │   ├── drilldown.js      # 模块下钻
 │   │   └── index.js          # 分析编排
 │   ├── diff.js               # 快照对比与风险规则
-│   ├── git.js                # mirror / worktree / 分支 / churn
-│   ├── db.js                 # SQLite
+│   ├── local-git.js          # 本地目录 Git 元数据 / churn
+│   ├── store.js              # 全局 JSON + 项目 .arcvista 存储
 │   ├── jobs.js               # 后台任务
-│   ├── llm.js                # OpenAI 兼容客户端
+│   ├── llm.js                # OpenAI 兼容客户端（独立模式）
 │   └── http.js               # 极小 HTTP 框架
 ├── public/                   # 零构建前端（原生 ES Modules + SVG）
 │   ├── css/
@@ -322,17 +309,17 @@ npm run dev     # node --watch 热重启
 
 ## 已知边界
 
-- 覆盖率优先使用仓库中的真实产物；没有产物时是**估算值**，只能用于判断覆盖明显偏低或缺失，不能当作真实覆盖率。
+- 覆盖率优先使用项目中的真实产物；没有产物时是**估算值**，只能用于判断覆盖明显偏低或缺失，不能当作真实覆盖率。
 - 安全守护与风险模式是启发式识别，结论会附证据路径，但仍建议人工复核。
 - 架构中的服务间调用来自网关路由、Feign 声明、导入关系与配置推断；运行期的动态调用（如反射、消息路由）可能无法完全还原。
-- 仓库扫描有文件数与单文件大小上限（默认 2 万文件 / 1.2MB），超大 monorepo 可调整 `scanRepo` 参数。
-- 私有仓库需要本机 git 凭据（SSH key 或 credential helper）可用。
-- 分支对比的语义依赖守护规则 ID、模块路径、API 路径的稳定性；大范围重命名会被视为删除 + 新增。
+- 项目扫描有文件数与单文件大小上限（默认 2 万文件 / 1.2MB），超大 monorepo 可调整 `scanRepo` 参数。
+- 非 Git 目录同样可以分析；Git 目录只需要本机可执行的 `git`，不需要网络。
+- 快照对比的语义依赖守护规则 ID、模块路径、API 路径的稳定性；大范围重命名会被视为删除 + 新增。
 - LLM 增强需要网络与模型费用；失败会自动回退到启发式分析并在快照中记录提示。
 
 ## 与 Archify 的关系
 
-架构图能力借鉴了 [Archify](../../.agents/skills/archify) 的分层表达与交互思路（分层、边界、图例、下钻），但 ArcVista 把它放进了持续观测的产品看板：仓库即数据源、快照可对比、结论可追溯，并增加了安全守护、知识图谱、复杂度、覆盖率与分支风险判断。
+架构图能力借鉴了 [Archify](../../.agents/skills/archify) 的分层表达与交互思路（分层、边界、图例、下钻），但 ArcVista 把它放进了持续观测的产品看板：本地目录即数据源、快照可对比、结论可追溯，并增加了安全守护、知识图谱、复杂度、覆盖率与分支风险判断。
 
 
 ## License

package/index.js

@@ -66,11 +66,26 @@ export function apply(ctx, config = {}) {
       path.join(os.homedir(), '.dsh', 'arcvista'),
   );
   const backupDir = path.resolve(config.backupDir || process.env.ARCVISTA_BACKUP_DIR || path.join(dataDir, 'backups'));
+  const listWorkspaces = () => {
+    try {
+      const registry = typeof ctx.get === 'function' ? ctx.get('workspaceRegistry') : undefined;
+      if (!registry?.list) return [];
+      return registry.list().map((workspace) => ({
+        id: String(workspace.id),
+        title: String(workspace.title || ''),
+        path: String(workspace.path || ''),
+        createdAt: workspace.createdAt || null,
+      }));
+    } catch {
+      return [];
+    }
+  };
   const app = createArcVistaApp({
     dataDir,
     publicDir: path.join(APP_ROOT, 'public'),
     backupDir,
     llm: createDshLlm(ctx),
+    workspaces: listWorkspaces,
   });
 
   const handler = async (req, res) => {

package/lib/analyze/index.js

@@ -1,4 +1,6 @@
+import fs from 'node:fs';
 import { scanRepo } from './walk.js';
+import { inspectProject, fileChurn } from '../local-git.js';
 import { detectModules } from './modules.js';
 import { buildGraph } from './graph.js';
 import { analyzeDeps } from './deps.js';
@@ -84,77 +86,27 @@ function buildSummary({ analysis, product }) {
 }
 
 /**
- * Clone/fetch the repository mirror and list remote branches WITHOUT running
- * the expensive analysis. The UI uses this as the first step after adding a repo,
- * so the user can see progress and then choose which branches to analyse.
+ * Analyse the current working tree of a local project directory. ArcVista does
+ * not clone, fetch or check out anything: the user's checkout is the source of
+ * truth, and all analysis artifacts are written to <project>/.arcvista.
  */
-export async function prepareRepository({ store, git, product, log, progress }) {
-  const startedAt = Date.now();
-  progress(3, '准备仓库');
-  log(`准备仓库 ${product.repoUrl}`);
-  let mirrorHigh = 0;
-  const { defaultBranch } = await git.ensureMirror(
-    product,
-    (message, level) => log(message, level),
-    (info) => {
-      const percent = Number(info?.percent) || 0;
-      mirrorHigh = Math.max(mirrorHigh, percent);
-      progress(5 + Math.round(mirrorHigh * 0.6), `拉取仓库 · ${info.detail || `${percent}%`}`);
-    },
-  );
-  if (defaultBranch && defaultBranch !== product.defaultBranch) {
-    store.products.update(product.id, { defaultBranch });
-  }
-  progress(70, '读取分支列表');
-  const branches = await git.listBranches(product.id).catch(() => []);
-  log(`仓库已就绪，检测到 ${branches.length} 个分支`);
-  progress(100, '仓库已就绪');
-  return {
-    defaultBranch: defaultBranch || product.defaultBranch,
-    branchCount: branches.length,
-    branches: branches.slice(0, 120).map((branch) => ({
-      name: branch.name,
-      short: branch.short,
-      date: branch.date,
-      subject: branch.subject,
-    })),
-    durationMs: Date.now() - startedAt,
-  };
-}
-
-/**
- * Full repository analysis: mirrors the repo, checks out one commit, runs every
- * collector, optionally enriches with the LLM, then persists a snapshot.
- */
-export async function analyzeRepository({ store, git, product, branch, force = false, llm, log, progress }) {
+export async function analyzeRepository({ store, product, force = false, llm, log, progress }) {
   const startedAt = Date.now();
   const warnings = [];
-
-  progress(3, '准备仓库镜像');
-  log(`准备分析 ${product.name}`);
-  let mirrorHigh = 0;
-  const { defaultBranch } = await git.ensureMirror(
-    product,
-    (message, level) => log(message, level),
-    (info) => {
-      const percent = Number(info?.percent) || 0;
-      mirrorHigh = Math.max(mirrorHigh, percent);
-      progress(3 + Math.round(mirrorHigh * 0.05), `准备仓库 · ${info.detail || `${percent}%`}`);
-    },
-  );
-  const targetBranch = branch || defaultBranch || product.defaultBranch || 'main';
-  if (defaultBranch && defaultBranch !== product.defaultBranch) {
-    store.products.update(product.id, { defaultBranch });
+  const projectPath = String(product.path || product.repoUrl || '').trim();
+  if (!projectPath || !fs.existsSync(projectPath) || !fs.statSync(projectPath).isDirectory()) {
+    throw new Error(`本地项目目录不存在或不可读：${projectPath || '(空)'}`);
   }
-  log(`目标分支 ${targetBranch}`);
 
-  progress(8, '解析提交');
-  const sha = await git.resolveRef(product.id, targetBranch);
-  const commit = await git.commitInfo(product.id, sha);
-  log(`提交 ${commit.short} · ${commit.subject}`);
+  progress(3, '读取本地项目');
+  log(`分析本地目录 ${projectPath}`);
+  const info = await inspectProject(projectPath);
+  const targetBranch = info.branch || '工作区';
+  const commit = info.commit;
+  log(`${info.isGit ? `当前分支 ${targetBranch}` : '非 Git 目录，按当前文件内容分析'} · ${commit.short || 'local'}`);
 
-  if (!force) {
-    const existing = store.snapshots.findByCommit(product.id, sha);
+  if (!force && !info.dirty && commit.sha) {
+    const existing = store.snapshots.findByCommit(product.id, commit.sha);
     if (existing) {
       log(`该提交已有分析快照（${existing.id}），直接复用`);
       progress(100, '已存在快照');
@@ -162,12 +114,8 @@ export async function analyzeRepository({ store, git, product, branch, force = f
     }
   }
 
-  progress(13, '检出代码');
-  const worktree = await git.ensureWorktree(product.id, sha, (message) => log(message));
-  await git.pruneWorktrees(product.id, [sha]).catch(() => {});
-
-  progress(20, '扫描仓库文件');
-  const repo = await scanRepo(worktree);
+  progress(20, '扫描本地文件');
+  const repo = await scanRepo(projectPath);
   log(`扫描到 ${repo.totals.files} 个文件 / ${repo.totals.sourceFiles} 个源文件 / ${repo.totals.sourceLoc} 行代码`);
   if (repo.truncated) {
     warnings.push('仓库文件数量超过扫描上限，部分文件被忽略');
@@ -192,7 +140,7 @@ export async function analyzeRepository({ store, git, product, branch, force = f
   log(coverage.measurable ? `解析到真实覆盖率：${coverage.line}%` : `未发现覆盖率产物，估算覆盖 ${coverage.line}%`);
 
   progress(52, '度量系统复杂度');
-  const churn = await git.fileChurn(product.id, sha).catch(() => ({ commits: 0, fileCommits: new Map() }));
+  const churn = await fileChurn(projectPath, commit.sha).catch(() => ({ commits: 0, fileCommits: new Map() }));
   const complexity = analyzeComplexity(repo, {
     modulesInfo,
     graph,
@@ -291,7 +239,8 @@ export async function analyzeRepository({ store, git, product, branch, force = f
     version: 1,
     meta: {
       productName: product.name,
-      repoUrl: product.repoUrl,
+      repoUrl: projectPath,
+      projectPath,
       branch: targetBranch,
       commit,
       analyzedAt,
@@ -341,7 +290,7 @@ export async function analyzeRepository({ store, git, product, branch, force = f
   progress(94, '保存快照');
   const summary = buildSummary({ analysis, product });
   const snapshotId = store.snapshots.insert({
-    id: force ? store.snapshots.findByCommit(product.id, sha)?.id : undefined,
+    id: force ? store.snapshots.findByCommit(product.id, commit.sha)?.id : undefined,
     productId: product.id,
     branch: targetBranch,
     commit,
@@ -357,8 +306,6 @@ export async function analyzeRepository({ store, git, product, branch, force = f
   } catch {
     /* backups must never break an analysis */
   }
-  await git.pruneWorktrees(product.id, [sha]).catch(() => {});
-
   log(`快照已保存，用时 ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
   progress(100, '分析完成');
   return {

package/lib/analyze/walk.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 
 /** Directories that never carry product source and would drown the scan. */
 export const EXCLUDED_DIRS = new Set([
-  'node_modules', '.git', '.hg', '.svn', 'dist', 'build', 'out', 'target',
+  'node_modules', '.git', '.arcvista', '.hg', '.svn', 'dist', 'build', 'out', 'target',
   '.next', '.nuxt', '.output', '.svelte-kit', '.turbo', '.parcel-cache',
   '.m2repo', '.m2', '.gradle', '.idea', '.vscode', 'vendor', 'Pods',
   '.venv', 'venv', 'env', '__pycache__', '.pytest_cache', '.tox', '.eggs',

package/lib/jobs.js

@@ -1,10 +1,10 @@
-import { newId, nowIso } from './db.js';
+import { newId, nowIso } from './store.js';
 
 const MAX_LOGS = 220;
 const FINISHED_RETENTION_MS = 10 * 60 * 1000;
 
 /**
- * In-process job queue persisted to SQLite.
+ * In-process job queue persisted to the global JSON store.
  * Heavy git/LLM work runs one job per product at a time; extra submissions are
  * queued and started in order, so "分析多个分支" can be submitted at once.
  */

package/lib/local-git.js

@@ -0,0 +1,121 @@
+/** Local-directory Git metadata. ArcVista never clones or checks out a project. */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import crypto from 'node:crypto';
+
+const execFileAsync = promisify(execFile);
+const TIMEOUT = Number(process.env.ARCVISTA_GIT_TIMEOUT_MS || 20000);
+const ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: '0',
+  GIT_OPTIONAL_LOCKS: '0',
+};
+
+async function git(projectPath, args, options = {}) {
+  const { stdout } = await execFileAsync('git', ['-C', projectPath, ...args], {
+    env: ENV,
+    timeout: options.timeout || TIMEOUT,
+    maxBuffer: options.maxBuffer || 32 * 1024 * 1024,
+  });
+  return String(stdout || '').trim();
+}
+
+export function localCommit(projectPath) {
+  const sha = `local-${crypto.createHash('sha1').update(projectPath).digest('hex').slice(0, 12)}`;
+  return {
+    sha,
+    short: 'local',
+    subject: '本地工作区',
+    author: '',
+    date: new Date().toISOString(),
+  };
+}
+
+export async function isGitRepository(projectPath) {
+  try {
+    return (await git(projectPath, ['rev-parse', '--is-inside-work-tree'])) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export async function inspectProject(projectPath) {
+  try {
+    const inside = await git(projectPath, ['rev-parse', '--is-inside-work-tree']);
+    if (inside !== 'true') throw new Error('not a work tree');
+    let branch = '';
+    try {
+      branch = await git(projectPath, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    } catch {
+      branch = (await git(projectPath, ['rev-parse', '--short', 'HEAD'])).trim();
+    }
+    const format = '%H%x00%h%x00%s%x00%an%x00%aI';
+    const text = await git(projectPath, ['show', '-s', `--format=${format}`, 'HEAD']);
+    const [sha, short, subject, author, date] = text.split('\u0000');
+    const status = await git(projectPath, ['status', '--porcelain', '--untracked-files=normal']);
+    return {
+      isGit: true,
+      branch: branch || 'HEAD',
+      commit: { sha, short, subject: subject || '', author: author || '', date: date || '' },
+      dirty: status.length > 0,
+      status,
+    };
+  } catch {
+    return {
+      isGit: false,
+      branch: '工作区',
+      commit: localCommit(projectPath),
+      dirty: true,
+      status: '',
+    };
+  }
+}
+
+/** The local workflow analyses exactly one checked-out state. */
+export async function listBranches(projectPath) {
+  const info = await inspectProject(projectPath);
+  return [
+    {
+      name: info.branch,
+      short: info.commit.short,
+      date: info.commit.date,
+      subject: info.commit.subject,
+      current: true,
+      isGit: info.isGit,
+    },
+  ];
+}
+
+export async function fileChurn(projectPath, sha, { days = 180, maxCommits = 400 } = {}) {
+  try {
+    if (!sha || String(sha).startsWith('local-')) return { commits: 0, fileCommits: new Map() };
+    const out = await git(
+      projectPath,
+      [
+        'log',
+        `--since=${days} days ago`,
+        '--no-merges',
+        `-n ${maxCommits}`,
+        '--format=commit:%H',
+        '--name-only',
+        sha,
+        '--',
+      ],
+      { timeout: 45000, maxBuffer: 48 * 1024 * 1024 },
+    );
+    const fileCommits = new Map();
+    let commits = 0;
+    for (const line of out.split('\n')) {
+      if (line.startsWith('commit:')) {
+        commits += 1;
+        continue;
+      }
+      const file = line.trim();
+      if (!file) continue;
+      fileCommits.set(file, (fileCommits.get(file) || 0) + 1);
+    }
+    return { commits, fileCommits };
+  } catch {
+    return { commits: 0, fileCommits: new Map() };
+  }
+}