c0de-agent 1.5.0 → 1.6.0

package/dist/project/resolve.js

@@ -1,7 +1,88 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+/** 目录聚合时的优先级（越大越优先展示）。ignored 最低：被忽略目录下若有真实变更仍显示变更态。 */
+export const GIT_STATUS_PRIORITY = {
+    conflict: 5,
+    untracked: 4,
+    modified: 3,
+    staged: 2,
+    deleted: 1,
+    ignored: 0,
+};
+/** porcelain XY → 单一分类。 */
+function classifyStatus(xy) {
+    const x = xy[0];
+    const y = xy[1];
+    if (x === '!' && y === '!')
+        return 'ignored'; // git 忽略项
+    // 合并冲突：任意 U，或双方同时增/删
+    if (x === 'U' || y === 'U' || (x === 'A' && y === 'A') || (x === 'D' && y === 'D'))
+        return 'conflict';
+    if (x === '?' && y === '?')
+        return 'untracked';
+    if (x === 'D' || y === 'D')
+        return 'deleted';
+    if (x !== ' ' && x !== '?')
+        return 'staged'; // 已暂存（新增/修改/重命名/复制）
+    if (y !== ' ' && y !== '?')
+        return 'modified'; // 工作区变更未暂存
+    return 'modified';
+}
+/**
+ * 取工作区 git status（porcelain v1, NUL 分隔），返回 path → 状态分类 的映射。
+ * path 为相对 cwd 的 POSIX 路径；非 git 仓库或失败返回 null。
+ */
+/** spawnSync 的 stdout/stderr maxBuffer 默认 1MB，大仓库可能超出。
+ * 10MB 足以覆盖大量 untracked 文件场景（此前 50MB 是为 --ignored 的 PGLite 数万文件预留，
+ * 去掉 --ignored 后不再需要）。 */
+const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10MB
+export function getGitStatus(cwd) {
+    let result;
+    try {
+        result = spawnSync('git', ['status', '--porcelain', '-z', '--untracked-files=all'], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: GIT_MAX_BUFFER,
+        });
+    }
+    catch {
+        return null;
+    }
+    if (result.error || result.status !== 0)
+        return null;
+    const raw = result.stdout ?? '';
+    const tokens = raw.split('\0');
+    const map = {};
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token === '')
+            break; // 末尾空 token
+        const xy = token.slice(0, 2);
+        const code = classifyStatus(xy);
+        const isRename = xy[0] === 'R' || xy[0] === 'C';
+        // 重命名/复制："XY oldpath\0newpath"，状态挂在 newpath
+        if (isRename && i + 1 < tokens.length) {
+            const newPath = tokens[i + 1];
+            map[normalizePath(newPath)] = code;
+            i += 2;
+        }
+        else {
+            const rest = token.slice(3); // 跳过 "XY "
+            if (rest)
+                map[normalizePath(rest)] = code;
+            i += 1;
+        }
+    }
+    return map;
+}
+/** 路径统一为 POSIX 相对（保留目录尾斜杠由调用方无需）。 */
+function normalizePath(p) {
+    return p.replace(/\\/g, '/');
+}
 /** 运行 git 命令，失败返回空字符串（不抛错）。 */
 function git(args, cwd) {
     try {
@@ -9,6 +90,7 @@ function git(args, cwd) {
             cwd,
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: GIT_MAX_BUFFER,
         });
         if (result.status !== 0 || result.error)
             return '';
@@ -18,6 +100,53 @@ function git(args, cwd) {
         return '';
     }
 }
+/** 检查给定路径中哪些被 gitignore 规则覆盖。
+ *
+ * 用 git check-ignore 只查询传入的路径（不递归），返回被忽略路径的集合。
+ * 只检查当前展开目录的直接子项（通常 10-50 个），不递归进 node_modules 等。
+ * 非 git 仓库或无忽略文件时返回空集。
+ *
+ * 注意：git check-ignore 在「无路径被忽略」或「非 git 仓库」时退出码为 1，
+ * 这两种情况都返回空集。 */
+export function checkIgnored(cwd, paths) {
+    if (paths.length === 0)
+        return new Set();
+    try {
+        const result = spawnSync('git', ['check-ignore', ...paths], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: GIT_MAX_BUFFER,
+        });
+        if (result.status !== 0 || result.error)
+            return new Set();
+        const raw = result.stdout ?? '';
+        return new Set(raw.split('\n').filter(Boolean).map(normalizePath));
+    }
+    catch {
+        return new Set();
+    }
+}
+/** 追加条目到 .gitignore（去重，文件不存在则创建）。 */
+export function appendToGitignore(cwd, patterns) {
+    const gitignorePath = join(cwd, '.gitignore');
+    let existing = '';
+    try {
+        existing = readFileSync(gitignorePath, 'utf-8');
+    }
+    catch {
+        // 文件不存在，视为空
+    }
+    const existingLines = new Set(existing
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean));
+    const toAppend = patterns.map((p) => p.trim()).filter((p) => p && !existingLines.has(p));
+    if (toAppend.length === 0)
+        return;
+    const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+    writeFileSync(gitignorePath, `${existing}${prefix}${toAppend.join('\n')}\n`);
+}
 /** 从 directory 向上查找 .git，返回仓库根；非 git 返回 null。 */
 function findGitRoot(directory) {
     let current = resolve(directory);
@@ -51,6 +180,129 @@ function firstRemoteUrl(cwd) {
         return '';
     return git(['remote', 'get-url', first], cwd);
 }
+/**
+ * 取当前分支名（非 git 仓库返回 null）。
+ */
+export function getGitBranch(cwd) {
+    const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    return branch || null;
+}
+/**
+ * 取最后一次提交信息（subject/hash/author/相对时间）。
+ * 非 git 仓库或无提交（如全新仓库）返回 null。
+ */
+export function getGitLastCommit(cwd) {
+    const line = git(['log', '-1', '--format=%s%x1f%h%x1f%an%x1f%cr'], cwd);
+    if (!line)
+        return null;
+    const [subject, hash, author, date] = line.split('\x1f');
+    if (!subject)
+        return null;
+    return {
+        subject: subject.trim(),
+        hash: (hash ?? '').trim(),
+        author: (author ?? '').trim(),
+        date: (date ?? '').trim(),
+    };
+}
+/**
+ * 取工作区变更摘要（供 LLM 生成 commit message）。
+ * 包含 staged + unstaged diff（相对 HEAD）和 untracked 文件名列表。
+ * 非 git 仓库或无变更返回 null。
+ */
+export function getGitDiffSummary(cwd) {
+    const diff = git(['diff', 'HEAD'], cwd);
+    const untracked = git(['ls-files', '--others', '--exclude-standard'], cwd);
+    const parts = [];
+    if (diff)
+        parts.push(diff);
+    if (untracked) {
+        const files = untracked
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (files.length > 0) {
+            parts.push(`Untracked files:\n${files.map((f) => `  ${f}`).join('\n')}`);
+        }
+    }
+    const combined = parts.join('\n\n');
+    if (!combined.trim())
+        return null;
+    const status = getGitStatus(cwd);
+    const fileCount = status ? Object.values(status).filter((c) => c !== 'ignored').length : 0;
+    return { diff: combined, fileCount };
+}
+/**
+ * 执行 git add -A + git commit。成功返回 commit 短 hash，失败返回 error 信息。
+ */
+export function performGitCommit(cwd, message) {
+    git(['add', '-A'], cwd);
+    const result = spawnSync('git', ['commit', '-m', message], {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        maxBuffer: GIT_MAX_BUFFER,
+    });
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? '').trim();
+        return { error: stderr || `git commit failed (exit ${result.status})` };
+    }
+    const hash = git(['rev-parse', '--short', 'HEAD'], cwd);
+    return { hash: hash || 'unknown' };
+}
+/**
+ * 列出本地分支及当前分支标记（非 git 仓库返回 null）。
+ */
+export function listGitBranches(cwd) {
+    // --format 自定义输出：每行 `current<TAB>refname<TAB>subject`
+    const raw = git(['branch', '--format=%(HEAD)%09%(refname:short)%09%(contents:subject)'], cwd);
+    if (!raw)
+        return null;
+    return raw
+        .split('\n')
+        .filter((l) => l.trim())
+        .map((line) => {
+        const [head, name, subject] = line.split('\t');
+        return {
+            name: (name ?? '').trim(),
+            current: (head ?? '').trim() === '*',
+            lastSubject: (subject ?? '').trim() || null,
+        };
+    })
+        .filter((b) => b.name);
+}
+/**
+ * 切换到指定分支（git checkout）。成功返回分支名，失败返回 error。
+ */
+export function checkoutGitBranch(cwd, branch) {
+    const result = spawnSync('git', ['checkout', branch], {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        maxBuffer: GIT_MAX_BUFFER,
+    });
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? '').trim();
+        return { error: stderr || `git checkout failed (exit ${result.status})` };
+    }
+    return { branch };
+}
+/**
+ * 创建并切换到新分支。成功返回分支名，失败返回 error。
+ */
+export function createGitBranch(cwd, name) {
+    const result = spawnSync('git', ['checkout', '-b', name], {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        maxBuffer: GIT_MAX_BUFFER,
+    });
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? '').trim();
+        return { error: stderr || `git checkout -b failed (exit ${result.status})` };
+    }
+    return { branch: name };
+}
 function hash16(input) {
     return createHash('sha256').update(input).digest('hex').slice(0, 16);
 }

package/dist/server/app.js

@@ -19,6 +19,7 @@ import { createProjectRoute } from './routes/project.js';
 import { createProviderRoute } from './routes/provider.js';
 import { createSessionRoute } from './routes/session.js';
 import { createTerminalRoute } from './routes/terminal.js';
+import { createTodoRoute } from './routes/todo.js';
 import { createToolRoute } from './routes/tool.js';
 import { createUpdateRoute } from './routes/update.js';
 import { createWorkflowsRoute } from './routes/workflows.js';
@@ -42,6 +43,7 @@ function createApp(ctx) {
     app.route('/api/chat', createChatRoute(ctx));
     app.route('/api/commands', createCommandsRoute(ctx));
     app.route('/api/tools', createToolRoute(ctx));
+    app.route('/api/todo', createTodoRoute(ctx));
     app.route('/api/update', createUpdateRoute(ctx));
     app.route('/api/config', createConfigRoute(ctx));
     app.route('/api/permissions', createPermissionsRoute(ctx));
@@ -63,6 +65,7 @@ function createApp(ctx) {
             '/api/chat',
             '/api/commands',
             '/api/tools',
+            '/api/todo',
             '/api/update',
             '/api/config',
             '/api/permissions',

package/dist/server/context.js

@@ -22,6 +22,7 @@ function createServerContext(opts) {
                 reg.register(def);
             return reg;
         })();
+    // 工作流注册表：测试工厂只含内置（项目级 discovery 由 buildServerContext 负责）。
     let _workflowRegistry;
     return {
         db: opts.db,
@@ -35,7 +36,7 @@ function createServerContext(opts) {
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
         agentRegistry,
-        // 工作流注册表：惰性初始化，只含内置（项目级 discovery 由 bootstrap 或 API 触发热加载）。
+        // 工作流注册表：惰性初始化，只含内置（测试工厂；生产路径走 buildServerContext）。
         get workflowRegistry() {
             if (!_workflowRegistry) {
                 _workflowRegistry = createWorkflowRegistry();

package/dist/server/dev.js

@@ -1,7 +1,7 @@
 // src/server/dev.ts
 import { Readable } from 'node:stream';
 import { createApp } from './app.js';
-import { buildServerContext, createDevDb } from './server.js';
+import { buildServerContext, createDevDb, releaseDevDbLock, resolveDbDir } from './server.js';
 /**
  * 开发环境入口：初始化并返回 Hono app。
  * 供 vite dev server 中间件复用，使前后端共享同一端口。
@@ -88,6 +88,8 @@ async function closeDevApp() {
         await db.close();
         delete g[DEV_DB_KEY];
     }
+    // Release cross-process lock so the next dev server can start cleanly.
+    releaseDevDbLock(resolveDbDir());
 }
 /**
  * 把 Node 请求桥接到 Hono app 并流式回写响应（支持 SSE）。

package/dist/server/routes/chat.js

@@ -131,6 +131,7 @@ function createChatRoute(ctx) {
                                 error: { _tag: 'unexpected', message: String(e) },
                             }),
                         });
+                        await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
                     }
                 });
             }
@@ -274,8 +275,14 @@ function createChatRoute(ctx) {
             stream.onAbort(() => {
                 ctx.agentManager.abort(sessionId);
             });
+            // 跟踪 done 事件是否已发送：agentLoop 正常完成时 yield done；
+            // 但 error/abort/max_turns 等路径不 yield done，需在 finally 补发。
+            // 否则前端 isStreaming 永远不会变 false，按钮卡在「终止」态。
+            let doneSent = false;
             try {
                 for await (const event of runAgent(state, userContent, deps)) {
+                    if (event._tag === 'done')
+                        doneSent = true;
                     await stream.writeSSE({
                         event: event._tag,
                         data: JSON.stringify(event),
@@ -300,6 +307,11 @@ function createChatRoute(ctx) {
                 });
             }
             finally {
+                // agentLoop 的 error/abort/max_turns 路径不 yield done，在此补发。
+                // 正常完成路径已在循环中 yield done，doneSent=true 时跳过避免重复。
+                if (!doneSent) {
+                    await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                }
                 // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
                 // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
                 await updateSessionLastRun(ctx.db, sessionId, {

package/dist/server/routes/commands.js

@@ -9,6 +9,7 @@ function createCommandsRoute(_ctx) {
             name: cmd.name,
             description: cmd.description,
             ...(cmd.argsHint ? { argsHint: cmd.argsHint } : {}),
+            ...(cmd.subcommands ? { subcommands: cmd.subcommands } : {}),
         }));
         return c.json({ commands });
     });

package/dist/server/routes/files.js

@@ -1,9 +1,14 @@
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { access, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
 import { Hono } from 'hono';
+import trash from 'trash';
+import { createSummarizer } from '../../core/compact.js';
 import { getProject } from '../../project/project.js';
+import { appendToGitignore, checkIgnored, checkoutGitBranch, createGitBranch, getGitBranch, getGitDiffSummary, getGitLastCommit, getGitStatus, listGitBranches, performGitCommit, } from '../../project/resolve.js';
 import { apiError } from '../middleware/error.js';
 import { safeResolve } from '../util/safe-path.js';
+/** 递归搜索时跳过的目录（体积大/为元数据噪音，避免递归进入）。 */
+const SEARCH_SKIP_DIRS = new Set(['.git', 'node_modules']);
 /** 递归收集文件列表（用于搜索）。 */
 async function collectFiles(dir, basePath, maxDepth = 5) {
     if (maxDepth < 0)
@@ -17,7 +22,7 @@ async function collectFiles(dir, basePath, maxDepth = 5) {
         return [];
     }
     for (const entry of entries) {
-        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+        if (entry.isDirectory() && SEARCH_SKIP_DIRS.has(entry.name))
             continue;
         const fullPath = join(dir, entry.name);
         const relPath = relative(basePath, fullPath);
@@ -60,6 +65,211 @@ function contentTypeFor(name) {
 }
 function createFilesRoute(ctx) {
     const app = new Hono();
+    // git 状态：返回 path → 状态分类 的映射（非 git 返回空对象）
+    app.get('/git-status', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        return c.json(getGitStatus(root) ?? {});
+    });
+    // 当前分支名（非 git 仓库返回 null）
+    app.get('/git-branch', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        return c.json({ branch: getGitBranch(root) });
+    });
+    // 最后一次提交信息（供分支名 hover tooltip）。非 git 仓库或无提交返回 commit null。
+    app.get('/git-last-commit', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        return c.json({ commit: getGitLastCommit(root) });
+    });
+    // 一键提交：用 LLM 生成 commit message + 检查可疑文件，支持 force/append-ignore 模式
+    app.post('/git-commit', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const summary = getGitDiffSummary(root);
+        if (!summary) {
+            return apiError(c, 400, 'NO_CHANGES', 'No changes to commit');
+        }
+        // 可选 body：mode / message / suggestions
+        const body = await c.req
+            .json()
+            .catch(() => ({}));
+        // --- mode: force — 跳过检查，用传入 message 直接提交 ---
+        if (body.mode === 'force') {
+            if (!body.message) {
+                return apiError(c, 400, 'MISSING_MESSAGE', 'mode=force requires a message');
+            }
+            const result = performGitCommit(root, body.message);
+            if ('error' in result) {
+                return apiError(c, 500, 'COMMIT_FAILED', result.error);
+            }
+            return c.json({
+                committed: true,
+                message: body.message,
+                hash: result.hash,
+                fileCount: summary.fileCount,
+            });
+        }
+        // --- mode: append-ignore — 追加 .gitignore 后提交 ---
+        if (body.mode === 'append-ignore') {
+            if (!body.message) {
+                return apiError(c, 400, 'MISSING_MESSAGE', 'mode=append-ignore requires a message');
+            }
+            if (!body.suggestions || body.suggestions.length === 0) {
+                return apiError(c, 400, 'MISSING_SUGGESTIONS', 'mode=append-ignore requires suggestions');
+            }
+            appendToGitignore(root, body.suggestions);
+            const result = performGitCommit(root, body.message);
+            if ('error' in result) {
+                return apiError(c, 500, 'COMMIT_FAILED', result.error);
+            }
+            return c.json({
+                committed: true,
+                message: body.message,
+                hash: result.hash,
+                fileCount: summary.fileCount,
+            });
+        }
+        // --- 默认模式：LLM 生成 message + 检查可疑文件 ---
+        const cm = ctx.config.commitModel;
+        const provider = cm?.provider ?? ctx.config.defaultProvider;
+        const model = cm?.model ?? ctx.config.defaultModel;
+        const prompt = `Based on the following git diff, generate a concise commit message in conventional-commits format (e.g. "feat: add login page").
+
+ALSO review the changed/new files: are any of them files that SHOULD be in .gitignore but are currently missing? (e.g. secrets, .env, build output, dependencies, temp files, large binaries)
+
+Reply as JSON ONLY:
+{"message": "<commit message>", "ignoreSuggestions": ["<path>", ...]}
+
+If no files need ignoring, return an empty array for ignoreSuggestions.
+
+${summary.diff.slice(0, 8000)}`;
+        let raw;
+        try {
+            const summarizer = createSummarizer(ctx.llmRegistry, provider, model, { maxTokens: 400 });
+            raw = (await summarizer(prompt)).trim();
+        }
+        catch (err) {
+            return apiError(c, 502, 'LLM_ERROR', `Failed to generate commit message: ${String(err)}`);
+        }
+        // LLM 返回可能含 markdown 代码块包裹，去掉
+        raw = raw
+            .replace(/^```[a-z]*\n?/m, '')
+            .replace(/\n?```$/m, '')
+            .trim();
+        // JSON 解析（fail-closed：无法解析 → 报错阻断，不提交）
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return apiError(c, 502, 'CHECK_PARSE_ERROR', 'Commit ignore check failed: LLM returned unparseable response');
+        }
+        const message = (parsed.message ?? '').trim();
+        if (!message) {
+            return apiError(c, 502, 'EMPTY_MESSAGE', 'LLM returned empty commit message');
+        }
+        const suggestions = Array.isArray(parsed.ignoreSuggestions) ? parsed.ignoreSuggestions : [];
+        // LLM 检测到可疑文件 → 阻断提交，返回供前端审查
+        if (suggestions.length > 0) {
+            return c.json({ needsReview: true, message, suggestions });
+        }
+        // 无可疑文件 → 直接提交
+        const result = performGitCommit(root, message);
+        if ('error' in result) {
+            return apiError(c, 500, 'COMMIT_FAILED', result.error);
+        }
+        return c.json({
+            committed: true,
+            message,
+            hash: result.hash,
+            fileCount: summary.fileCount,
+        });
+    });
+    // 列出本地分支（非 git 仓库返回空数组）
+    app.get('/git-branches', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        return c.json({ branches: listGitBranches(root) ?? [] });
+    });
+    // 切换分支（git checkout）
+    app.post('/git-checkout', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const body = await c.req.json().catch(() => ({}));
+        const branch = body.branch;
+        if (!branch)
+            return apiError(c, 400, 'BAD_REQUEST', 'branch is required');
+        const result = checkoutGitBranch(root, branch);
+        if ('error' in result) {
+            return apiError(c, 500, 'CHECKOUT_FAILED', result.error);
+        }
+        return c.json({ branch: result.branch });
+    });
+    // 创建并切换到新分支（git checkout -b）
+    app.post('/git-branch-create', async (c) => {
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const body = await c.req.json().catch(() => ({}));
+        const name = body.name;
+        if (!name)
+            return apiError(c, 400, 'BAD_REQUEST', 'name is required');
+        const result = createGitBranch(root, name);
+        if ('error' in result) {
+            return apiError(c, 500, 'BRANCH_CREATE_FAILED', result.error);
+        }
+        return c.json({ branch: result.branch });
+    });
     // 列出目录
     // projectId 指定时按对应项目 worktree 列出，否则回退 ctx.cwd（向后兼容）。
     app.get('/', async (c) => {
@@ -79,8 +289,7 @@ function createFilesRoute(ctx) {
         }
         try {
             const entries = await readdir(resolved, { withFileTypes: true });
-            const result = entries
-                .filter((e) => !e.name.startsWith('.'))
+            const sorted = entries
                 .map((e) => ({
                 name: e.name,
                 type: (e.isDirectory() ? 'directory' : 'file'),
@@ -90,6 +299,14 @@ function createFilesRoute(ctx) {
                     return a.type === 'directory' ? -1 : 1;
                 return a.name.localeCompare(b.name);
             });
+            // git check-ignore：只检查当前目录直接子项，标记被忽略的文件/目录（灰显用）
+            const prefix = queryPath === '.' ? '' : `${queryPath}/`;
+            const checkPaths = sorted.map((e) => `${prefix}${e.name}`);
+            const ignoredSet = checkIgnored(root, checkPaths);
+            const result = sorted.map((e) => ({
+                ...e,
+                ...(ignoredSet.has(`${prefix}${e.name}`) ? { ignored: true } : {}),
+            }));
             return c.json(result);
         }
         catch {
@@ -178,6 +395,37 @@ function createFilesRoute(ctx) {
             return apiError(c, 500, 'WRITE_ERROR', `Failed to write file: ${String(err)}`);
         }
     });
+    // 删除文件/目录（移入系统回收站）
+    // projectId 指定时按对应项目 worktree 解析，否则回退 ctx.cwd（向后兼容）。
+    app.delete('/*', async (c) => {
+        const path = c.req.path.replace(/^\/api\/files\//, '').replace(/^\//, '');
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const resolved = safeResolve(root, path);
+        if (!resolved) {
+            return apiError(c, 403, 'FORBIDDEN', 'Path outside workspace');
+        }
+        try {
+            await access(resolved);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'File not found');
+        }
+        try {
+            await trash(resolved);
+            return c.json({ path, trashed: true });
+        }
+        catch (err) {
+            return apiError(c, 500, 'DELETE_ERROR', `Failed to delete file: ${String(err)}`);
+        }
+    });
     return app;
 }
 export { createFilesRoute };