minimal-agent 0.11.0 → 0.12.0

package/src/tools/trash/trash.js

@@ -0,0 +1,233 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { access, cp, lstat, mkdir, readdir, readlink, rename, rm, realpath, } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, isAbsolute, join, relative, resolve, sep, } from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+const exec = promisify(execFile);
+const schema = z.discriminatedUnion('action', [
+    z.object({
+        action: z.literal('move'),
+        paths: z.array(z.string().min(1)).min(1).max(200),
+    }),
+    z.object({
+        action: z.literal('git-clean'),
+        include_ignored: z.boolean().default(false).optional(),
+    }),
+]);
+function inside(root, path) {
+    const rel = relative(root, path);
+    return (rel === '' ||
+        (!rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel)));
+}
+async function gitRoot(cwd) {
+    try {
+        return await realpath((await exec('git', ['-C', cwd, 'rev-parse', '--show-toplevel'])).stdout.trim());
+    }
+    catch {
+        return undefined;
+    }
+}
+async function validate(path, cwd) {
+    const lexical = resolve(cwd, path);
+    const target = await realpath(lexical);
+    const root = await gitRoot(cwd);
+    if (root) {
+        const git = join(root, '.git');
+        if (target === root ||
+            inside(target, root) ||
+            lexical === git ||
+            inside(git, lexical) ||
+            inside(git, target))
+            throw new Error(`拒绝移动 Git 仓库根目录、其祖先或 .git：${target}`);
+    }
+    await lstat(lexical);
+    return lexical;
+}
+async function fallbackTrash(source) {
+    const files = process.platform === 'linux'
+        ? join(homedir(), '.local/share/Trash/files')
+        : join(homedir(), '.Trash');
+    const info = join(homedir(), '.local/share/Trash/info');
+    await mkdir(files, { recursive: true, mode: 0o700 });
+    if (process.platform === 'linux')
+        await mkdir(info, { recursive: true, mode: 0o700 });
+    const name = `${basename(source)}.${new Date().toISOString().replace(/[:.]/g, '-')}.${randomUUID().slice(0, 8)}`;
+    const target = join(files, name);
+    try {
+        await rename(source, target);
+    }
+    catch {
+        await cp(source, target, {
+            recursive: true,
+            errorOnExist: true,
+            preserveTimestamps: true,
+        });
+        if ((await treeFingerprint(source)) !== (await treeFingerprint(target)))
+            throw new Error('跨卷复制内容校验失败，来源已保留');
+        await rm(source, { recursive: true });
+    }
+    if (process.platform === 'linux') {
+        const encoded = encodeURI(source).replace(/#/g, '%23');
+        await import('node:fs/promises').then((fs) => fs.writeFile(join(info, `${name}.trashinfo`), `[Trash Info]\nPath=${encoded}\nDeletionDate=${new Date().toISOString().slice(0, 19)}\n`, { mode: 0o600 }));
+    }
+    return target;
+}
+async function treeFingerprint(path) {
+    const hash = createHash('sha256');
+    const visit = async (current, relativePath) => {
+        const info = await lstat(current);
+        if (info.isSymbolicLink()) {
+            hash.update(`link\0${relativePath}\0${await readlink(current)}\0`);
+            return;
+        }
+        if (info.isDirectory()) {
+            hash.update(`dir\0${relativePath}\0`);
+            const entries = await readdir(current);
+            entries.sort();
+            for (const entry of entries)
+                await visit(join(current, entry), join(relativePath, entry));
+            return;
+        }
+        hash.update(`file\0${relativePath}\0${info.size}\0`);
+        for await (const chunk of createReadStream(current))
+            hash.update(chunk);
+    };
+    await visit(path, '.');
+    return hash.digest('hex');
+}
+async function missing(path) {
+    return access(path)
+        .then(() => false)
+        .catch((error) => {
+        if (error.code === 'ENOENT')
+            return true;
+        throw error;
+    });
+}
+async function moveMany(sources) {
+    if (process.platform === 'darwin') {
+        try {
+            await exec('osascript', [
+                '-e',
+                'on run argv',
+                '-e',
+                'tell application "Finder"',
+                '-e',
+                'repeat with sourcePath in argv',
+                '-e',
+                'delete POSIX file (sourcePath as text)',
+                '-e',
+                'end repeat',
+                '-e',
+                'end tell',
+                '-e',
+                'end run',
+                ...sources,
+            ]);
+            if ((await Promise.all(sources.map(missing))).every(Boolean))
+                return 'macOS Trash';
+        }
+        catch { }
+    }
+    if (process.platform === 'win32') {
+        const script = `Add-Type -AssemblyName Microsoft.VisualBasic; foreach ($path in $args) { if ([IO.Directory]::Exists($path)) { [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory($path,'OnlyErrorDialogs','SendToRecycleBin') } else { [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile($path,'OnlyErrorDialogs','SendToRecycleBin') } }`;
+        try {
+            await exec('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                script,
+                ...sources,
+            ]);
+            if ((await Promise.all(sources.map(missing))).every(Boolean))
+                return 'Windows Recycle Bin';
+        }
+        catch { }
+    }
+    if (process.platform === 'linux') {
+        try {
+            await exec('gio', ['trash', '--', ...sources]);
+            if ((await Promise.all(sources.map(missing))).every(Boolean))
+                return 'FreeDesktop Trash';
+        }
+        catch { }
+    }
+    for (const source of sources) {
+        if (await access(source)
+            .then(() => true)
+            .catch(() => false))
+            await fallbackTrash(source);
+    }
+    return process.platform === 'linux' ? 'FreeDesktop Trash' : 'system Trash';
+}
+async function gitCleanCandidates(cwd, ignored) {
+    const root = await gitRoot(cwd);
+    if (!root)
+        throw new Error('当前目录不在 Git 仓库中');
+    const read = async (extra) => {
+        const out = (await exec('git', [
+            '-C',
+            root,
+            'ls-files',
+            '-z',
+            '--others',
+            '--directory',
+            '--exclude-standard',
+            ...extra,
+        ], { encoding: 'buffer', maxBuffer: 64 * 1024 * 1024 })).stdout;
+        return out.toString('utf8').split('\0').filter(Boolean);
+    };
+    const names = [
+        ...(await read([])),
+        ...(ignored ? await read(['--ignored']) : []),
+    ];
+    const values = [...new Set(names)].map((p) => resolve(root, p.replace(/\/$/, '')));
+    return values.filter((p, i) => !values.some((other, j) => j !== i && inside(other, p)));
+}
+async function call(input, context) {
+    const cwd = context.cwd ?? process.cwd();
+    try {
+        const raw = input.action === 'move'
+            ? input.paths
+            : await gitCleanCandidates(cwd, input.include_ignored ?? false);
+        const paths = [];
+        for (const item of raw)
+            paths.push(await validate(item, cwd));
+        const moved = [];
+        const destination = paths.length ? await moveMany(paths) : '';
+        for (const path of paths) {
+            try {
+                await access(path);
+                throw new Error(`回收站操作后来源仍存在：${path}`);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+            moved.push(`${path} → ${destination}`);
+        }
+        return {
+            ok: true,
+            content: moved.length
+                ? `已移动到系统回收站，可从回收站恢复：\n${moved.join('\n')}`
+                : '没有匹配的未跟踪文件。',
+        };
+    }
+    catch (e) {
+        return { ok: false, error: `Trash 失败：${e.message}` };
+    }
+}
+export const trashTool = {
+    name: 'Trash',
+    description: 'Recoverably removes files or directories by moving them to the operating system Trash/Recycle Bin. Use action=git-clean to trash untracked Git files without running git clean. Repository roots and .git are always refused.',
+    inputSchema: schema,
+    parameters: toToolParameters(schema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    call: async () => ({ ok: false, error: 'Trash requires runtime context' }),
+    callWithContext: (input, _s, ctx) => call(input, ctx),
+};

package/src/tools/trash/trash.ts

@@ -0,0 +1,283 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import {
+  access,
+  cp,
+  lstat,
+  mkdir,
+  readdir,
+  readlink,
+  rename,
+  rm,
+  realpath,
+} from 'node:fs/promises';
+import { homedir } from 'node:os';
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+  sep,
+} from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+
+const exec = promisify(execFile);
+const schema = z.discriminatedUnion('action', [
+  z.object({
+    action: z.literal('move'),
+    paths: z.array(z.string().min(1)).min(1).max(200),
+  }),
+  z.object({
+    action: z.literal('git-clean'),
+    include_ignored: z.boolean().default(false).optional(),
+  }),
+]);
+type Input = z.infer<typeof schema>;
+function inside(root: string, path: string): boolean {
+  const rel = relative(root, path);
+  return (
+    rel === '' ||
+    (!rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel))
+  );
+}
+async function gitRoot(cwd: string): Promise<string | undefined> {
+  try {
+    return await realpath(
+      (
+        await exec('git', ['-C', cwd, 'rev-parse', '--show-toplevel'])
+      ).stdout.trim(),
+    );
+  } catch {
+    return undefined;
+  }
+}
+async function validate(path: string, cwd: string): Promise<string> {
+  const lexical = resolve(cwd, path);
+  const target = await realpath(lexical);
+  const root = await gitRoot(cwd);
+  if (root) {
+    const git = join(root, '.git');
+    if (
+      target === root ||
+      inside(target, root) ||
+      lexical === git ||
+      inside(git, lexical) ||
+      inside(git, target)
+    )
+      throw new Error(`拒绝移动 Git 仓库根目录、其祖先或 .git：${target}`);
+  }
+  await lstat(lexical);
+  return lexical;
+}
+async function fallbackTrash(source: string): Promise<string> {
+  const files =
+    process.platform === 'linux'
+      ? join(homedir(), '.local/share/Trash/files')
+      : join(homedir(), '.Trash');
+  const info = join(homedir(), '.local/share/Trash/info');
+  await mkdir(files, { recursive: true, mode: 0o700 });
+  if (process.platform === 'linux')
+    await mkdir(info, { recursive: true, mode: 0o700 });
+  const name = `${basename(source)}.${new Date().toISOString().replace(/[:.]/g, '-')}.${randomUUID().slice(0, 8)}`;
+  const target = join(files, name);
+  try {
+    await rename(source, target);
+  } catch {
+    await cp(source, target, {
+      recursive: true,
+      errorOnExist: true,
+      preserveTimestamps: true,
+    });
+    if ((await treeFingerprint(source)) !== (await treeFingerprint(target)))
+      throw new Error('跨卷复制内容校验失败，来源已保留');
+    await rm(source, { recursive: true });
+  }
+  if (process.platform === 'linux') {
+    const encoded = encodeURI(source).replace(/#/g, '%23');
+    await import('node:fs/promises').then((fs) =>
+      fs.writeFile(
+        join(info, `${name}.trashinfo`),
+        `[Trash Info]\nPath=${encoded}\nDeletionDate=${new Date().toISOString().slice(0, 19)}\n`,
+        { mode: 0o600 },
+      ),
+    );
+  }
+  return target;
+}
+
+async function treeFingerprint(path: string): Promise<string> {
+  const hash = createHash('sha256');
+  const visit = async (
+    current: string,
+    relativePath: string,
+  ): Promise<void> => {
+    const info = await lstat(current);
+    if (info.isSymbolicLink()) {
+      hash.update(`link\0${relativePath}\0${await readlink(current)}\0`);
+      return;
+    }
+    if (info.isDirectory()) {
+      hash.update(`dir\0${relativePath}\0`);
+      const entries = await readdir(current);
+      entries.sort();
+      for (const entry of entries)
+        await visit(join(current, entry), join(relativePath, entry));
+      return;
+    }
+    hash.update(`file\0${relativePath}\0${info.size}\0`);
+    for await (const chunk of createReadStream(current)) hash.update(chunk);
+  };
+  await visit(path, '.');
+  return hash.digest('hex');
+}
+
+async function missing(path: string): Promise<boolean> {
+  return access(path)
+    .then(() => false)
+    .catch((error: NodeJS.ErrnoException) => {
+      if (error.code === 'ENOENT') return true;
+      throw error;
+    });
+}
+
+async function moveMany(sources: string[]): Promise<string> {
+  if (process.platform === 'darwin') {
+    try {
+      await exec('osascript', [
+        '-e',
+        'on run argv',
+        '-e',
+        'tell application "Finder"',
+        '-e',
+        'repeat with sourcePath in argv',
+        '-e',
+        'delete POSIX file (sourcePath as text)',
+        '-e',
+        'end repeat',
+        '-e',
+        'end tell',
+        '-e',
+        'end run',
+        ...sources,
+      ]);
+      if ((await Promise.all(sources.map(missing))).every(Boolean))
+        return 'macOS Trash';
+    } catch {}
+  }
+  if (process.platform === 'win32') {
+    const script = `Add-Type -AssemblyName Microsoft.VisualBasic; foreach ($path in $args) { if ([IO.Directory]::Exists($path)) { [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory($path,'OnlyErrorDialogs','SendToRecycleBin') } else { [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile($path,'OnlyErrorDialogs','SendToRecycleBin') } }`;
+    try {
+      await exec('powershell.exe', [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        script,
+        ...sources,
+      ]);
+      if ((await Promise.all(sources.map(missing))).every(Boolean))
+        return 'Windows Recycle Bin';
+    } catch {}
+  }
+  if (process.platform === 'linux') {
+    try {
+      await exec('gio', ['trash', '--', ...sources]);
+      if ((await Promise.all(sources.map(missing))).every(Boolean))
+        return 'FreeDesktop Trash';
+    } catch {}
+  }
+  for (const source of sources) {
+    if (
+      await access(source)
+        .then(() => true)
+        .catch(() => false)
+    )
+      await fallbackTrash(source);
+  }
+  return process.platform === 'linux' ? 'FreeDesktop Trash' : 'system Trash';
+}
+async function gitCleanCandidates(
+  cwd: string,
+  ignored: boolean,
+): Promise<string[]> {
+  const root = await gitRoot(cwd);
+  if (!root) throw new Error('当前目录不在 Git 仓库中');
+  const read = async (extra: string[]) => {
+    const out = (
+      await exec(
+        'git',
+        [
+          '-C',
+          root,
+          'ls-files',
+          '-z',
+          '--others',
+          '--directory',
+          '--exclude-standard',
+          ...extra,
+        ],
+        { encoding: 'buffer', maxBuffer: 64 * 1024 * 1024 } as any,
+      )
+    ).stdout as unknown as Buffer;
+    return out.toString('utf8').split('\0').filter(Boolean);
+  };
+  const names = [
+    ...(await read([])),
+    ...(ignored ? await read(['--ignored']) : []),
+  ];
+  const values = [...new Set(names)].map((p) =>
+    resolve(root, p.replace(/\/$/, '')),
+  );
+  return values.filter(
+    (p, i) => !values.some((other, j) => j !== i && inside(other, p)),
+  );
+}
+async function call(
+  input: Input,
+  context: ToolCallContext,
+): Promise<ToolResult> {
+  const cwd = context.cwd ?? process.cwd();
+  try {
+    const raw =
+      input.action === 'move'
+        ? input.paths
+        : await gitCleanCandidates(cwd, input.include_ignored ?? false);
+    const paths = [];
+    for (const item of raw) paths.push(await validate(item, cwd));
+    const moved = [];
+    const destination = paths.length ? await moveMany(paths) : '';
+    for (const path of paths) {
+      try {
+        await access(path);
+        throw new Error(`回收站操作后来源仍存在：${path}`);
+      } catch (e) {
+        if ((e as NodeJS.ErrnoException).code !== 'ENOENT') throw e;
+      }
+      moved.push(`${path} → ${destination}`);
+    }
+    return {
+      ok: true,
+      content: moved.length
+        ? `已移动到系统回收站，可从回收站恢复：\n${moved.join('\n')}`
+        : '没有匹配的未跟踪文件。',
+    };
+  } catch (e) {
+    return { ok: false, error: `Trash 失败：${(e as Error).message}` };
+  }
+}
+export const trashTool: Tool<Input> = {
+  name: 'Trash',
+  description:
+    'Recoverably removes files or directories by moving them to the operating system Trash/Recycle Bin. Use action=git-clean to trash untracked Git files without running git clean. Repository roots and .git are always refused.',
+  inputSchema: schema,
+  parameters: toToolParameters(schema),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  call: async () => ({ ok: false, error: 'Trash requires runtime context' }),
+  callWithContext: (input, _s, ctx) => call(input, ctx),
+};

package/src/tools/worktree/sessionWorktree.js

@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { join } from 'node:path';
+import { readRuntimeJson, sessionRuntimeDir, writeRuntimeJson, } from '../../session/runtimeStore.js';
+import { applyAgentWorktree, commitWorktreeChanges, createAgentWorktree, hasWorktreeChanges, removeAgentWorktree, } from '../agent/worktree.js';
+const enterSchema = z.object({
+    name: z
+        .string()
+        .regex(/^[a-zA-Z0-9._-]{1,48}$/)
+        .optional(),
+});
+const exitSchema = z.object({ action: z.enum(['apply', 'keep', 'discard']) });
+async function persist(ctx, state) {
+    await writeRuntimeJson(join(sessionRuntimeDir(ctx), 'worktree.json'), {
+        active: state ?? null,
+    });
+}
+export async function hydrateSessionWorktree(ctx) {
+    if (!ctx.sessionState || ctx.sessionState.activeWorktree)
+        return;
+    const saved = await readRuntimeJson(join(sessionRuntimeDir(ctx), 'worktree.json'), {});
+    if (saved.active)
+        ctx.sessionState.activeWorktree = saved.active;
+}
+async function enter(input, ctx) {
+    const state = ctx.sessionState;
+    if (!state)
+        return { ok: false, error: 'EnterWorktree 需要会话状态' };
+    if (state.activeWorktree)
+        return {
+            ok: true,
+            content: `当前已在 worktree ${state.activeWorktree.path}`,
+        };
+    const slug = `session-${input.name ?? randomUUID().slice(0, 8)}`;
+    const wt = await createAgentWorktree(slug, ctx.cwd);
+    if (!wt.ok)
+        return wt;
+    state.activeWorktree = {
+        id: slug,
+        path: wt.path,
+        branch: wt.branch,
+        baseSha: wt.baseSha,
+        gitRoot: wt.gitRoot,
+    };
+    await persist(ctx, state.activeWorktree);
+    return {
+        ok: true,
+        content: `已进入主 Agent 隔离 worktree：${wt.path}\n分支：${wt.branch}\n后续工具调用立即使用该目录。`,
+    };
+}
+async function exit(input, ctx) {
+    const state = ctx.sessionState, wt = state?.activeWorktree;
+    if (!state || !wt)
+        return { ok: false, error: '当前会话没有活动 worktree' };
+    if (input.action === 'keep') {
+        state.activeWorktree = undefined;
+        await persist(ctx, undefined);
+        return {
+            ok: true,
+            content: `已退出有效 cwd，但保留 worktree：${wt.path}\n分支：${wt.branch}`,
+        };
+    }
+    const changed = await hasWorktreeChanges(wt.path, wt.baseSha);
+    if (input.action === 'discard' && changed) {
+        const committed = await commitWorktreeChanges(wt.path, `archive: preserve discarded session ${wt.id}`);
+        if (committed.ok) {
+            state.activeWorktree = undefined;
+            await persist(ctx, undefined);
+        }
+        return committed.ok
+            ? {
+                ok: true,
+                content: `检测到成果，未永久删除。已归档到分支 ${wt.branch}，worktree 保留在 ${wt.path}。`,
+            }
+            : {
+                ok: false,
+                error: `无法安全归档，worktree 保持活动：${committed.error}`,
+            };
+    }
+    if (input.action === 'discard') {
+        await removeAgentWorktree(wt.path, wt.branch, wt.gitRoot);
+        state.activeWorktree = undefined;
+        await persist(ctx, undefined);
+        return {
+            ok: true,
+            content: 'worktree 无改动，已通过 Git worktree 管理安全清理。',
+        };
+    }
+    const committed = await commitWorktreeChanges(wt.path, `minimal-agent: apply session ${wt.id}`);
+    if (!committed.ok)
+        return {
+            ok: false,
+            error: `提交隔离改动失败，worktree 保持活动：${committed.error}`,
+        };
+    const applied = await applyAgentWorktree(wt.gitRoot, wt.id);
+    if (!applied.ok)
+        return {
+            ok: false,
+            error: `应用检查失败，worktree 保持活动：${applied.error}`,
+        };
+    state.activeWorktree = undefined;
+    await persist(ctx, undefined);
+    return {
+        ok: true,
+        content: `已通过 git apply --check 并将变更应用到原工作区；未自动提交。`,
+    };
+}
+export const enterWorktreeTool = {
+    name: 'EnterWorktree',
+    description: 'Creates and enters a session-scoped Git worktree for the main Agent. Later tool calls use it immediately while project memory keeps the original workspace identity.',
+    inputSchema: enterSchema,
+    parameters: toToolParameters(enterSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    call: async () => ({ ok: false, error: 'requires session context' }),
+    callWithContext: (i, _s, c) => enter(i, c),
+};
+export const exitWorktreeTool = {
+    name: 'ExitWorktree',
+    description: 'Leaves the current session worktree. apply checks and applies its patch to the original workspace; keep preserves it; discard never destroys uncommitted results and archives changed work.',
+    inputSchema: exitSchema,
+    parameters: toToolParameters(exitSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    call: async () => ({ ok: false, error: 'requires session context' }),
+    callWithContext: (i, _s, c) => exit(i, c),
+};