@movevom/9t 0.1.0

package/cli-9t/index.mjs

@@ -0,0 +1,652 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, rmSync, existsSync } from "fs";
+import { join, resolve, dirname, isAbsolute, sep } from "path";
+import { exec, execFile } from "child_process";
+import readline from "readline";
+import { homedir } from "os";
+
+const rootDir = resolve(dirname(new URL(import.meta.url).pathname), "..");
+const legacyProviderPath = join(rootDir, "config", "provider.json");
+const workspaceRoot = join(rootDir, "workspace");
+
+const toolsMeta = [
+  { name: "read", args: "{ path, offset?, limit? }", desc: "读取文件" },
+  { name: "edit", args: "{ path, find, replace }", desc: "局部替换" },
+  { name: "create", args: '{ path, type?: "file"|"dir", content? }', desc: "创建文件/目录" },
+  { name: "delete", args: "{ path }", desc: "删除文件/目录" },
+  { name: "ls", args: "{ path? }", desc: "列目录" },
+  { name: "grep", args: "{ pattern, path? }", desc: "搜索内容" },
+  { name: "glob", args: "{ pattern, path? }", desc: "按模式匹配文件" },
+  { name: "execute", args: "{ cmd, cwd? }", desc: "执行命令" },
+  { name: "open", args: "{ target }", desc: "打开文件/URL" }
+];
+
+const systemToolsText = toolsMeta.map((t) => `${t.name}: ${t.args}`).join("\n");
+const helpToolsText = toolsMeta.map((t) => `${t.name} ${t.desc}`).join("；");
+
+const SYSTEM_PROMPT = `你是 9T 工具代理。你只能输出 JSON，不要输出其它文字。
+格式：
+{"tool":"create","args":{...}} 或 {"tools":[{"tool":"create","args":{...}}, ...]} 或 {"final":"..."}
+可用工具与参数：
+${systemToolsText}
+所有 path 必须为相对 workspace 的路径，不要使用绝对路径或 ..`;
+
+const MAX_STEPS = 8;
+
+const testPrompt = "使用9T工具创建文件夹 demo ，在其中创建 test.md，内容为：山高月小，水落石出。";
+const toolHelpText = `可用工具与用途：${helpToolsText}`;
+const aboutText =
+  "9T-Movevom 是一个最小可用的 CLI 工具代理，使用 ChatGLM（glm-5）通过工具调用完成文件与命令操作。默认工作区为 Movevom/workspace。";
+const helpText =
+  "可用指令：/help /about /tools /? /exit /keystatus。输入自然语言任务可让 9T 调用工具执行。";
+
+const getConfigDir = () => {
+  const custom = process.env["9T_CONFIG_HOME"];
+  if (custom) return custom;
+  const home = homedir();
+  if (process.platform === "darwin") return join(home, "Library", "Application Support", "9T");
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"] || join(home, "AppData", "Roaming");
+    return join(appData, "9T");
+  }
+  return join(process.env["XDG_CONFIG_HOME"] || join(home, ".config"), "9t");
+};
+
+const providerPath = join(getConfigDir(), "provider.json");
+
+const defaultProvider = {
+  base_url: "https://open.bigmodel.cn/api/anthropic",
+  model: "glm-5"
+};
+
+const loadProviderConfig = () => {
+  if (existsSync(providerPath)) {
+    const raw = readFileSync(providerPath, "utf-8");
+    return JSON.parse(raw);
+  }
+  if (existsSync(legacyProviderPath)) {
+    const raw = readFileSync(legacyProviderPath, "utf-8");
+    return JSON.parse(raw);
+  }
+  return { ...defaultProvider };
+};
+
+const saveProviderConfig = (cfg) => {
+  mkdirSync(dirname(providerPath), { recursive: true });
+  const safe = { base_url: cfg.base_url, model: cfg.model };
+  writeFileSync(providerPath, JSON.stringify(safe, null, 2));
+};
+
+const config = loadProviderConfig();
+const baseUrl = String(config.base_url || defaultProvider.base_url).trim().replace(/\/$/, "");
+const model = String(config.model || defaultProvider.model).trim();
+let apiKey = "";
+
+if (!baseUrl || !model) {
+  console.error("provider.json 需要 base_url、model");
+  process.exit(1);
+}
+
+const keychainService = "9T-Movevom";
+const keychainAccount = "default";
+const isDarwin = process.platform === "darwin";
+const isWindows = process.platform === "win32";
+const isLinux = process.platform === "linux";
+
+const execFileAsync = (cmd, args, input) =>
+  new Promise((resolvePromise, reject) => {
+    const child = execFile(cmd, args, (err, stdout) => {
+      if (err) reject(err);
+      else resolvePromise(String(stdout || "").trim());
+    });
+    if (input != null) {
+      child.stdin.write(input);
+      child.stdin.end();
+    }
+  });
+
+const getKeychainApiKeyDarwin = async () => {
+  try {
+    return await execFileAsync("security", [
+      "find-generic-password",
+      "-a",
+      keychainAccount,
+      "-s",
+      keychainService,
+      "-w"
+    ]);
+  } catch {
+    return "";
+  }
+};
+
+const saveKeychainApiKeyDarwin = async (key) => {
+  await execFileAsync("security", [
+    "add-generic-password",
+    "-a",
+    keychainAccount,
+    "-s",
+    keychainService,
+    "-w",
+    key,
+    "-U"
+  ]);
+};
+
+const getKeychainApiKeyLinux = async () => {
+  try {
+    return await execFileAsync("secret-tool", [
+      "lookup",
+      "service",
+      keychainService,
+      "account",
+      keychainAccount
+    ]);
+  } catch {
+    return "";
+  }
+};
+
+const saveKeychainApiKeyLinux = async (key) => {
+  await execFileAsync(
+    "secret-tool",
+    ["store", "--label", keychainService, "service", keychainService, "account", keychainAccount],
+    key
+  );
+};
+
+const getKeychainApiKeyWindows = async () => {
+  const script = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public class CredMan {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct CREDENTIAL {
+    public int Flags;
+    public int Type;
+    public string TargetName;
+    public string Comment;
+    public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public string TargetAlias;
+    public string UserName;
+  }
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+  public static extern bool CredRead(string target, int type, int reserved, out IntPtr credPtr);
+  [DllImport("advapi32.dll", SetLastError=true)]
+  public static extern bool CredFree(IntPtr credPtr);
+}
+"@;
+$target = "${keychainService}";
+$credPtr = [IntPtr]::Zero;
+if ([CredMan]::CredRead($target, 1, 0, [ref]$credPtr)) {
+  $cred = [Runtime.InteropServices.Marshal]::PtrToStructure($credPtr, [type]::GetType("CredMan+CREDENTIAL"));
+  $password = [Runtime.InteropServices.Marshal]::PtrToStringUni($cred.CredentialBlob, $cred.CredentialBlobSize / 2);
+  [CredMan]::CredFree($credPtr);
+  Write-Output $password;
+}`;
+  try {
+    return await execFileAsync("powershell", ["-NoProfile", "-Command", script]);
+  } catch {
+    return "";
+  }
+};
+
+const saveKeychainApiKeyWindows = async (key) => {
+  const script = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public class CredMan {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct CREDENTIAL {
+    public int Flags;
+    public int Type;
+    public string TargetName;
+    public string Comment;
+    public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public string TargetAlias;
+    public string UserName;
+  }
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+  public static extern bool CredWrite([In] ref CREDENTIAL userCredential, [In] uint flags);
+}
+"@;
+$secret = [Console]::In.ReadToEnd();
+$secret = $secret.Trim();
+$bytes = [Text.Encoding]::Unicode.GetBytes($secret);
+$cred = New-Object CredMan+CREDENTIAL;
+$cred.Type = 1;
+$cred.TargetName = "${keychainService}";
+$cred.UserName = "${keychainAccount}";
+$cred.CredentialBlobSize = $bytes.Length;
+$cred.CredentialBlob = [Runtime.InteropServices.Marshal]::AllocHGlobal($bytes.Length);
+[Runtime.InteropServices.Marshal]::Copy($bytes, 0, $cred.CredentialBlob, $bytes.Length);
+$cred.Persist = 2;
+[CredMan]::CredWrite([ref]$cred, 0) | Out-Null;
+[Runtime.InteropServices.Marshal]::FreeHGlobal($cred.CredentialBlob);
+`;
+  await execFileAsync("powershell", ["-NoProfile", "-Command", script], key);
+};
+
+const getStoredApiKey = async () => {
+  if (isDarwin) return await getKeychainApiKeyDarwin();
+  if (isLinux) return await getKeychainApiKeyLinux();
+  if (isWindows) return await getKeychainApiKeyWindows();
+  return "";
+};
+
+const saveStoredApiKey = async (key) => {
+  if (isDarwin) return await saveKeychainApiKeyDarwin(key);
+  if (isLinux) return await saveKeychainApiKeyLinux(key);
+  if (isWindows) return await saveKeychainApiKeyWindows(key);
+};
+
+const promptHidden = (label) =>
+  new Promise((resolvePromise) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let input = "";
+    const onData = (char) => {
+      const c = String(char);
+      if (c === "\r" || c === "\n") {
+        stdout.write("\n");
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        resolvePromise(input.trim());
+        return;
+      }
+      if (c === "\u0003") {
+        stdout.write("\n");
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        process.exit(1);
+      }
+      if (c === "\u007f") {
+        input = input.slice(0, -1);
+        return;
+      }
+      input += c;
+    };
+    stdout.write(label);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+  });
+
+const ensureApiKey = async () => {
+  const envKey = String(process.env["9T_API_KEY"] || "").trim();
+  if (envKey) return envKey;
+  const keychainKey = await getStoredApiKey();
+  if (keychainKey) return keychainKey;
+  const input = await promptHidden("apikey: ");
+  if (!input) {
+    throw new Error("api_key 不能为空");
+  }
+  try {
+    await saveStoredApiKey(input);
+  } catch (e) {
+    console.error("无法安全存储 api_key，请安装系统密钥存储后重试");
+  }
+  return input;
+};
+
+const migratePlaintextApiKey = async () => {
+  const fromFile = String(config.api_key || "").trim();
+  if (!fromFile) return;
+  await saveStoredApiKey(fromFile);
+  delete config.api_key;
+  saveProviderConfig(config);
+};
+
+mkdirSync(workspaceRoot, { recursive: true });
+saveProviderConfig({ base_url: baseUrl, model });
+
+const resolveWorkspacePath = (p) => {
+  if (!p || typeof p !== "string") throw new Error("path required");
+  if (isAbsolute(p)) throw new Error("absolute path not allowed");
+  const full = resolve(workspaceRoot, p);
+  if (full !== workspaceRoot && !full.startsWith(workspaceRoot + sep)) {
+    throw new Error("path escape not allowed");
+  }
+  return full;
+};
+
+const toolRead = (args) => {
+  const filePath = resolveWorkspacePath(args.path);
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split(/\r?\n/);
+  const offset = Math.max(0, (args.offset || 0) - 1);
+  const limit = Math.max(1, args.limit || 200);
+  const slice = lines.slice(offset, offset + limit);
+  return { content: slice.join("\n"), lines: slice.length, offset: offset + 1 };
+};
+
+const toolEdit = (args) => {
+  const filePath = resolveWorkspacePath(args.path);
+  const content = readFileSync(filePath, "utf-8");
+  const find = String(args.find || "");
+  const replace = String(args.replace || "");
+  if (!find) throw new Error("find required");
+  if (!content.includes(find)) throw new Error("find not found");
+  const next = content.replace(find, replace);
+  writeFileSync(filePath, next);
+  return { ok: true };
+};
+
+const toolCreate = (args) => {
+  const type = args.type === "dir" ? "dir" : "file";
+  const target = resolveWorkspacePath(args.path);
+  if (type === "dir") {
+    mkdirSync(target, { recursive: true });
+    return { ok: true, type };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  const content = args.content == null ? "" : String(args.content);
+  writeFileSync(target, content);
+  return { ok: true, type };
+};
+
+const toolDelete = (args) => {
+  const target = resolveWorkspacePath(args.path);
+  rmSync(target, { recursive: true, force: true });
+  return { ok: true };
+};
+
+const toolLs = (args) => {
+  const target = resolveWorkspacePath(args?.path || ".");
+  const entries = readdirSync(target, { withFileTypes: true }).map((e) => {
+    const full = join(target, e.name);
+    const st = statSync(full);
+    return {
+      name: e.name,
+      type: e.isDirectory() ? "dir" : "file",
+      size: st.size
+    };
+  });
+  return { entries };
+};
+
+const walkFiles = (dir, out) => {
+  const items = readdirSync(dir, { withFileTypes: true });
+  for (const item of items) {
+    const full = join(dir, item.name);
+    if (item.isDirectory()) {
+      walkFiles(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+};
+
+const toolGrep = (args) => {
+  const base = resolveWorkspacePath(args?.path || ".");
+  const pattern = String(args.pattern || "");
+  if (!pattern) throw new Error("pattern required");
+  let regex;
+  try {
+    regex = new RegExp(pattern, "g");
+  } catch {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    regex = new RegExp(escaped, "g");
+  }
+  const files = [];
+  walkFiles(base, files);
+  const matches = [];
+  for (const f of files) {
+    const content = readFileSync(f, "utf-8");
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, i) => {
+      if (regex.test(line)) {
+        matches.push({ file: f.replace(workspaceRoot + sep, ""), line: i + 1, text: line });
+      }
+      regex.lastIndex = 0;
+    });
+  }
+  return { matches };
+};
+
+const globToRegex = (pattern) => {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regex = escaped
+    .replace(/\*\*/g, "###DOUBLESTAR###")
+    .replace(/\*/g, "[^/]*")
+    .replace(/\?/g, ".");
+  const withDouble = regex.replace(/###DOUBLESTAR###/g, ".*");
+  return new RegExp("^" + withDouble + "$");
+};
+
+const toolGlob = (args) => {
+  const base = resolveWorkspacePath(args?.path || ".");
+  const pattern = String(args.pattern || "");
+  if (!pattern) throw new Error("pattern required");
+  const files = [];
+  walkFiles(base, files);
+  const regex = globToRegex(pattern);
+  const matches = files
+    .map((f) => f.replace(workspaceRoot + sep, ""))
+    .filter((p) => regex.test(p));
+  return { matches };
+};
+
+const toolExecute = (args) =>
+  new Promise((resolvePromise, reject) => {
+    const cmd = String(args.cmd || "");
+    if (!cmd) return reject(new Error("cmd required"));
+    const cwd = args.cwd ? resolveWorkspacePath(args.cwd) : workspaceRoot;
+    exec(cmd, { cwd, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        resolvePromise({ ok: false, code: err.code || 1, stdout, stderr });
+      } else {
+        resolvePromise({ ok: true, code: 0, stdout, stderr });
+      }
+    });
+  });
+
+const toolOpen = (args) =>
+  new Promise((resolvePromise, reject) => {
+    const target = String(args.target || "");
+    if (!target) return reject(new Error("target required"));
+    const platform = process.platform;
+    let cmd = "";
+    if (platform === "darwin") cmd = `open "${target}"`;
+    else if (platform === "win32") cmd = `start "" "${target}"`;
+    else cmd = `xdg-open "${target}"`;
+    exec(cmd, (err, stdout, stderr) => {
+      if (err) resolvePromise({ ok: false, stdout, stderr });
+      else resolvePromise({ ok: true, stdout, stderr });
+    });
+  });
+
+const toolMap = {
+  read: toolRead,
+  edit: toolEdit,
+  create: toolCreate,
+  delete: toolDelete,
+  ls: toolLs,
+  grep: toolGrep,
+  glob: toolGlob,
+  execute: toolExecute,
+  open: toolOpen
+};
+
+const extractJson = (text) => {
+  const cleaned = text.replace(/```json|```/g, "").trim();
+  const firstBrace = cleaned.indexOf("{");
+  const lastBrace = cleaned.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace !== -1) {
+    const slice = cleaned.slice(firstBrace, lastBrace + 1);
+    return JSON.parse(slice);
+  }
+  const firstBracket = cleaned.indexOf("[");
+  const lastBracket = cleaned.lastIndexOf("]");
+  if (firstBracket !== -1 && lastBracket !== -1) {
+    const slice = cleaned.slice(firstBracket, lastBracket + 1);
+    return JSON.parse(slice);
+  }
+  throw new Error("no json found");
+};
+
+const callModel = async (messages) => {
+  const res = await fetch(`${baseUrl}/v1/messages`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 1024,
+      temperature: 0,
+      system: SYSTEM_PROMPT,
+      messages
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    const msg = data?.error?.message || "request failed";
+    throw new Error(msg);
+  }
+  const content = Array.isArray(data.content) ? data.content : [];
+  const text = content.map((c) => c.text || "").join("").trim();
+  return text;
+};
+
+const runPrompt = async (messages, prompt) => {
+  messages.push({ role: "user", content: prompt });
+  for (let step = 0; step < MAX_STEPS; step++) {
+    const text = await callModel(messages);
+    messages.push({ role: "assistant", content: text });
+    let parsed;
+    try {
+      parsed = extractJson(text);
+    } catch (e) {
+      throw new Error(`invalid model json: ${String(e.message || e)}`);
+    }
+    if (parsed.final) {
+      return parsed.final;
+    }
+    const calls = parsed.tools || (parsed.tool ? [parsed] : []);
+    if (!calls.length) {
+      throw new Error("no tool calls");
+    }
+    for (const call of calls) {
+      const name = call.tool;
+      const args = call.args || {};
+      const fn = toolMap[name];
+      if (!fn) throw new Error(`unknown tool: ${name}`);
+      const result = await fn(args);
+      messages.push({
+        role: "user",
+        content: `TOOL_RESULT ${name} ${JSON.stringify(result)}`
+      });
+    }
+  }
+  return "max steps reached";
+};
+
+const hasFlag = (args, flag) => args.includes(flag);
+
+const isToolHelpQuery = (input) =>
+  /工具/.test(input) && /(做什么|用途|能做什么|可以用哪些)/.test(input);
+
+const runInteractive = async () => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const messages = [];
+  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+  console.log("9T 交互模式，输入 /exit 退出");
+  while (true) {
+    const input = String(await question("> ")).trim();
+    if (!input) continue;
+    if (input === "/exit" || input === "/quit") break;
+    if (input === "/tools" || input === "/?" || isToolHelpQuery(input)) {
+      console.log(toolHelpText);
+      continue;
+    }
+    if (input === "/help") {
+      console.log(helpText);
+      continue;
+    }
+    if (input === "/about") {
+      console.log(aboutText);
+      continue;
+    }
+    if (input === "/keystatus") {
+      const envKey = String(process.env["9T_API_KEY"] || "").trim();
+      if (envKey) {
+        console.log("api_key 已通过环境变量提供");
+        continue;
+      }
+      const stored = await getStoredApiKey();
+      console.log(stored ? "api_key 已安全存储" : "api_key 未存储");
+      continue;
+    }
+    try {
+      const out = await runPrompt(messages, input);
+      if (out !== undefined && out !== null) console.log(out);
+    } catch (e) {
+      console.error(String(e?.message || e));
+    }
+  }
+  rl.close();
+};
+
+const run = async () => {
+  const args = process.argv.slice(2);
+  const interactive = hasFlag(args, "--interactive") || hasFlag(args, "-i");
+  const testMode = hasFlag(args, "--test");
+  const keyStatusMode = hasFlag(args, "--key-status");
+  const filteredArgs = args.filter(
+    (a) => a !== "--interactive" && a !== "-i" && a !== "--test" && a !== "--key-status"
+  );
+  await migratePlaintextApiKey();
+  if (keyStatusMode) {
+    const envKey = String(process.env["9T_API_KEY"] || "").trim();
+    if (envKey) {
+      console.log("api_key 已通过环境变量提供");
+      return;
+    }
+    const stored = await getStoredApiKey();
+    console.log(stored ? "api_key 已安全存储" : "api_key 未存储");
+    return;
+  }
+  apiKey = await ensureApiKey();
+
+  if (testMode) {
+    const messages = [];
+    const out = await runPrompt(messages, testPrompt);
+    if (out !== undefined && out !== null) console.log(out);
+    return;
+  }
+
+  if (interactive || filteredArgs.length === 0) {
+    await runInteractive();
+    return;
+  }
+
+  const prompt = filteredArgs.join(" ").trim();
+  if (!prompt) {
+    await runInteractive();
+    return;
+  }
+  const messages = [];
+  const out = await runPrompt(messages, prompt);
+  if (out !== undefined && out !== null) console.log(out);
+};
+
+run().catch((e) => {
+  console.error(String(e?.message || e));
+  process.exit(1);
+});

package/config/provider.json

@@ -0,0 +1,5 @@
+{
+  "base_url": "https://open.bigmodel.cn/api/anthropic",
+  "model": "glm-5",
+  "api_key": ""
+}

package/docs/001-9t-plan.md

@@ -0,0 +1,124 @@
+# 001｜9T（九工具）独立 AI Agent 设计草案
+
+## 1. 整体思路与背景
+
+### 1.1 背景
+- LLM 很强大，但本质是“对话脑”，缺少直接执行现实任务的手脚
+- 现有工具与系统能力很丰富，需要一个统一入口与治理层
+- 权限管理是核心底线，避免误删、越权与不可逆损失
+
+### 1.2 设计思路
+- 9T 是“工具层与治理层”，负责列出工具、统一协议、权限与路径管理
+- LLM 作为“大脑”负责决策，9T 作为“手脚”负责执行与反馈
+- 安全是第一原则：工具调用前后都要可审计、可拦截、可回放
+- 体验是目标：给人类用户更直观的 UI/UX 与可控的风险提示
+
+### 1.3 你可能遗漏但需要补足的维度
+- **任务生命周期**：任务状态、失败回滚、断点续跑、恢复能力
+- **可观察性**：操作日志、工具调用轨迹、成本与耗时统计
+- **模型治理**：多模型路由、失败回退、限额与速率控制
+- **配置分层**：用户级/项目级/组织级策略覆盖与冲突处理
+- **扩展机制**：插件/技能/外部工具接入的安全边界
+- **多端体验**：CLI、Web、Desktop 之间的一致性与权限同步
+
+## 2. 9T 工具在 mac / Linux / Windows 的实现方式（参考写法）
+
+> 目标：工具语义统一，底层按平台适配；优先用内部实现保证一致性，必要时落到系统命令。
+
+### 1.1 read（读取文件）
+- macOS/Linux：`cat <file>`、`sed -n '1,200p' <file>`、`head -n 200 <file>`
+- Windows（PowerShell）：`Get-Content <file> -TotalCount 200`
+
+### 1.2 edit（局部编辑/补丁）
+- macOS/Linux：建议使用“统一 diff/patch 规范”由程序应用，必要时 `git apply` 或 `patch -p0`
+- Windows（PowerShell）：建议由程序应用补丁，或使用 `git apply`（依赖 Git）
+
+### 1.3 create（创建文件/目录）
+- macOS/Linux：`touch <file>`、`mkdir -p <dir>`
+- Windows（PowerShell）：`New-Item -ItemType File <file>`、`New-Item -ItemType Directory <dir>`
+
+### 1.4 delete（删除）
+- macOS/Linux：`rm <file>`、`rm -rf <dir>`
+- Windows（PowerShell）：`Remove-Item <file>`、`Remove-Item -Recurse -Force <dir>`
+
+### 1.5 ls（列目录）
+- macOS/Linux：`ls -la <dir>`
+- Windows（PowerShell）：`Get-ChildItem <dir>`
+
+### 1.6 grep（内容搜索）
+- macOS/Linux：`rg "<pattern>" <dir>` 或 `grep -R "<pattern>" <dir>`
+- Windows（PowerShell）：`Select-String -Path <dir>\* -Pattern "<pattern>" -Recurse`
+
+### 1.7 glob（文件匹配）
+- macOS/Linux：`find <dir> -path "<glob>"` 或 `fd "<pattern>" <dir>`
+- Windows（PowerShell）：`Get-ChildItem -Path <dir> -Filter "<glob>" -Recurse`
+
+### 1.8 execute（执行命令）
+- macOS/Linux：`bash -lc "<cmd>"` 或直接执行 `<cmd>`
+- Windows（PowerShell）：`powershell -NoProfile -Command "<cmd>"`
+
+### 1.9 open（打开文件/URL）
+- macOS：`open <path|url>`
+- Linux：`xdg-open <path|url>`
+- Windows：`start <path|url>`
+
+## 3. 9T Agent 设计是否有先例、如何借鉴
+
+### 2.1 先例与核心思想
+- **Claude Code**：工具权限通过规则控制（Read/Edit/Bash/WebFetch 等）；规则支持 allow/ask/deny，优先级严格；权限设计强调“最小授权 + 可追踪”。[Claude Code Permissions](https://code.claude.com/docs/en/permissions)
+- **Codex CLI**：有“审批模式”，默认允许在工作区内读/写/执行；针对超出范围会请求确认；强调工作区隔离与安全提示。[Codex CLI Features](https://developers.openai.com/codex/cli/features/) [Codex Security](https://developers.openai.com/codex/security/)
+- **Gemini CLI**：提供沙箱配置，默认限制写入范围；执行修改性命令时提示确认；支持多目录工作区配置与权限级别切换。[Gemini CLI Configuration](https://geminicli.com/docs/get-started/configuration/) [Gemini CLI Codelab](https://codelabs.developers.google.com/gemini-cli-hands-on)
+
+### 2.2 9T Agent 的推荐结构
+- **统一工具协议**：工具调用统一 JSON，包含 `tool`、`input`、`cwd`、`timeout`、`risk`、`reason`、`dryRun` 等字段。
+- **权限模型**：三段式策略 `deny > ask > allow`；默认 ask；高风险工具（delete/execute/open）强制二次确认。
+- **工作区隔离（更细化）**：所有读写默认限制在 workspace root；执行类工具的 `cwd` 必须落在 workspace；路径统一标准化（realpath）并拒绝软链逃逸；对 `..`、绝对路径、跨盘符访问进行拦截或强制 ask；workspace 之外仅允许白名单目录（如用户显式添加的 include dirs）；对 delete/edit/create 必须进行“目标路径在白名单内”的硬校验。
+- **命令域约束**：execute 仅允许白名单命令前缀或已登记的命令模板；对 `curl/wget` 等网络访问类命令默认 ask 或 deny。
+- **审计日志**：每次工具调用记录输入、输出摘要、耗时、状态码，便于回放与归责。
+- **可插拔工具**：核心 9T 固化，其余扩展走插件或 MCP。
+
+### 2.3 Codex 工作区隔离 vs Gemini 沙箱（差异重点）
+- **Codex**：以“工作区权限”为核心，审批模式决定可自动执行的范围；对超出工作区或需要网络访问的动作提示确认，强调工作区范围内读/写/执行的授权边界。[Codex Security](https://developers.openai.com/codex/security/)
+- **Gemini CLI**：通过沙箱配置文件控制系统层级的限制，默认限制写入到项目目录，支持更严格/自定义沙箱配置，强调 OS 级隔离与可切换的沙箱策略。[Gemini CLI Configuration](https://geminicli.com/docs/get-started/configuration/)
+- **总结**：Codex 更偏“权限审批 + 工作区边界控制”，Gemini 更偏“沙箱策略 + 系统层隔离”，二者可组合成“策略层 + 系统层”双保险。
+
+### 2.4 处理危险操作/链接/恶意代码的硬性机制（除沙箱/隔离外）
+- **硬编码 denylist**：拒绝高风险命令与路径模式（例如 `rm -rf /`、系统目录写入、浏览器/钥匙串路径）。
+- **可执行文件审计**：对新生成的可执行文件要求显式确认；对脚本写入后执行要求二次确认。
+- **网络访问策略**：对外网域名/IP 设白名单；URL 需通过分类器或规则过滤；对下载/执行链路强制“下载 → 扫描 → 允许执行”。
+- **内容扫描**：对写入内容进行静态规则扫描（危险指令片段、已知恶意模式、敏感凭据写入）。
+- **文件类型策略**：对 `.bashrc`、`~/.ssh/*`、系统配置文件等敏感目标默认 deny。
+- **工具分级**：read/ls/grep 低风险自动；edit/create 中风险 ask；delete/execute/open 高风险强制 ask+二次确认。
+
+## 4. 除 9T 外建议新增的能力（最小增量）
+- **move/rename**：独立工具利于权限审计，避免用 execute 隐式完成。
+- **stat**：查询文件/目录元信息（大小/时间/权限）。
+- **diff/patch**：与 edit 配套，便于回滚与审计。
+- **ask_user**：让模型在关键节点询问用户，降低误操作风险。
+- **web_fetch / web_search**：研究与资料收集（可选开关）。
+- **process**：列出/终止进程（用于任务管理）。
+
+## 5. Claude Code / Codex / Gemini CLI 的设计逻辑对比（可借鉴要点）
+
+### 4.1 交互逻辑
+- Claude Code：REPL + /config 等命令，权限通过规则系统配置，工具可被精细化限制。[Claude Code Settings](https://code.claude.com/docs/en/settings)
+- Codex CLI：交互会话 + /permissions 动态调整审批等级；默认在工作区内自由读/写/执行。[Codex CLI Features](https://developers.openai.com/codex/cli/features/)
+- Gemini CLI：命令执行前提示确认；提供沙箱配置与多目录工作区；支持扩展与技能体系。[Gemini CLI Configuration](https://geminicli.com/docs/get-started/configuration/) [Gemini CLI Commands](https://geminicli.com/docs/cli/commands/)
+- 9T 当前交互约定：默认进入交互模式；提供 `/tools`、`/?`、`/help`、`/about`、`/exit` 指令，便于查看工具与帮助
+
+### 4.2 权限与能力边界
+- Claude Code：权限规则适用于 Read/Edit/Bash/WebFetch 等；规则可按路径/模式控制，默认偏保守。[Claude Code Permissions](https://code.claude.com/docs/en/permissions)
+- Codex CLI：审批模式决定自动程度；对超出工作区或网络相关动作提示确认。[Codex Security](https://developers.openai.com/codex/security/)
+- Gemini CLI：默认限制写入范围，并可切换不同沙箱配置；高风险命令会提示确认。[Gemini CLI Configuration](https://geminicli.com/docs/get-started/configuration/)
+
+### 4.3 可扩展性
+- Claude Code：支持子代理与工具白名单/黑名单策略，便于细粒度任务隔离。[Claude Code Sub-agents](https://code.claude.com/docs/en/sub-agents)
+- Codex CLI：支持 MCP 工具接入与扩展服务。[Codex CLI Features](https://developers.openai.com/codex/cli/features/)
+- Gemini CLI：支持扩展与技能管理、工作区管理命令。[Gemini CLI Commands](https://geminicli.com/docs/cli/commands/)
+
+## 6. 9T Agent 的建议落地路线（最小可用）
+1. 定义工具协议与统一返回格式（成功/失败/输出/错误码）。
+2. 实现 9T 工具最小版本（read/edit/create/delete/ls/grep/glob/execute/open）。
+3. 加入权限层：默认 ask + 高风险二次确认 + workspace 隔离。
+4. 加入审计日志与回放能力。
+5. 按需扩展 move/rename、stat、diff/patch、process、web。

package/docs/002-9t-phase0.md

@@ -0,0 +1,26 @@
+# 002｜9T Phase0 实现总结
+
+## 1. 当前已实现
+- 最小可用 9T CLI 客户端，可在终端直接运行并调用工具链完成文件操作
+- 9T 工具集合：read / edit / create / delete / ls / grep / glob / execute / open
+- ChatGLM 接入：使用 glm-5 模型与 `https://open.bigmodel.cn/api/anthropic` 作为请求基址
+- 运行方式：默认启动交互模式；支持单次命令模式与 `--test` 测试模式
+- 交互指令：`/tools`、`/?`、`/help`、`/about`、`/exit`
+- 工作区隔离：所有路径限制在 Movevom/workspace 内
+
+## 2. 目录与入口
+- Movevom/config/provider.json：保存 base_url、model、api_key
+- Movevom/cli-9t/index.mjs：CLI 主入口
+- Movevom/workspace：工具操作的工作区
+
+## 3. 核心实现方式
+- 通过系统提示词约束模型仅输出 JSON 工具调用
+- 客户端解析 JSON，映射到 9T 工具执行
+- 工具执行结果以 `TOOL_RESULT` 回写到对话上下文，驱动下一步工具调用
+- 路径统一解析为 workspace 相对路径，拒绝绝对路径与越界访问
+
+## 4. 交互与验证方式
+- 单次命令：`9t "<任务文本>"`，模型完成后输出 final
+- 交互对话：`9t` 默认进入交互模式，通过 9T 工具修改/创建文件
+- 测试模式：`9t --test` 生成 `demo/test.md` 并写入“惠风和畅”
+- 验证结果：在 Movevom/workspace 内生成目标文件即可视为成功

package/docs/plan/003-doc-npm.md

@@ -0,0 +1,147 @@
+# 003｜9T CLI 权限与多设备安装（方案草案）
+
+## 1. 文件夹权限（工作区与授权目录）
+- 目标：既能严格限制在 workspace 内，又可在用户同意后扩展到 Documents/Downloads 等授权目录；始终可回退为仅 workspace。
+- 默认策略（安全默认）：  
+  - 路径必须相对工作区，拒绝绝对路径与 `..` 越级  
+  - 软链逃逸防护：对目标路径做 `realpath` 标准化后再校验是否落在允许集合  
+  - 高风险工具（delete/execute/open）强制更严规则（见模式说明）
+- 模式设计：  
+  - strict：仅 workspace（默认），delete/execute/open 禁止或需显式启用  
+  - supervised：workspace + 显式授权目录（allowlist），高风险工具 ask/二次确认  
+  - open：workspace + 授权目录，按规则直接执行（不推荐）
+- 授权目录（allowlist）  
+  - macOS 常用：`~/Documents`、`~/Downloads`（通过 `~` 展开到绝对路径）  
+  - Linux：`~/Documents`、`~/Downloads`  
+  - Windows：`%USERPROFILE%\\Documents`、`%USERPROFILE%\\Downloads`
+- 配置入口（不改现有实现，仅描述方案）  
+  - 配置文件：优先按平台存放（若全局安装）  
+    - macOS：`~/Library/Application Support/9T/config.json`  
+    - Linux：`$XDG_CONFIG_HOME/9t/config.json` 或 `~/.config/9t/config.json`  
+    - Windows：`%AppData%\\9T\\config.json`  
+  - 环境变量（覆盖配置文件）：  
+    - `9T_ALLOWED_DIRS`：逗号分隔的绝对路径列表  
+    - `9T_MODE`：`strict|supervised|open`  
+  - CLI 参数（优先级最高）：  
+    - `--mode <strict|supervised|open>`  
+    - `--roots "<abs1,abs2,...>"`（授权目录列表）  
+    - `--workspace <path>`（覆盖工作区根）  
+- 执行时校验（关键点）  
+  - 统一将所有传入路径标准化后比较：  
+    - 若 `realpath(target)` 不在 `[workspace] ∪ [allowlist]` 中，拒绝或进入 ask 流程（由模式决定）  
+  - 对 delete/execute/open：  
+    - strict：拒绝（或要求带 `--allow-risk delete|execute|open` 才可执行）  
+    - supervised：询问二次确认（交互/标志）  
+    - open：按规则直接执行  
+
+## 2. 本地联调（不经发布的快速调试）
+- 目标：避免“修改 → 发布 → 安装 → 调试”，实现“修改 → 本地调试”
+- 推荐方式 A：直接运行入口文件  
+-  - 进入仓库后执行：`node Movevom/cli-9t/index.mjs`  
+  - 适合最轻量的本地验证，不依赖全局安装
+- 推荐方式 B：全局软链接（npm link）  
+  - 在 9T 项目根目录执行：`npm link`  
+  - 在任意目录直接使用：`9t`  
+  - 修改代码后无需重新安装，命令仍指向本地源码  
+  - 取消软链接：`npm unlink -g 9t`（或 `9t-movevom`）
+- 推荐方式 C：本地 PATH 指向  
+  - 把 `Movevom/cli-9t` 加入 PATH 或创建本地别名  
+  - 适合脚本化或团队内共享的本地开发流程
+
+## 3. 多设备安装与命令行分发（npm 路线）
+- 包名与命令名  
+-  - 包名：`@movevom/9t`  
+  - 命令名：`9t`
+- 目录与打包要点  
+  - 使用 ESModule（`"type": "module"`），将 `cli-9t/index.mjs` 作为 `bin` 入口  
+  - Node.js 要求：≥ 18（内置 fetch；统一运行时行为）  
+  - 跨平台：通过 Node 实现文件/命令工具，避免平台特定依赖
+- 全局安装与更新  
+-  - 全局安装：`npm i -g @movevom/9t`  
+  - 运行：`9t`（默认直接进入交互模式）  
+  - 测试：`9t --test`（创建 `demo/test.md` 并写入“惠风和畅”）  
+  - 更新：`npm update -g @movevom/9t`
+- 多设备配置（与权限配置结合）  
+  - Provider（LLM）配置默认路径：  
+    - macOS：`~/Library/Application Support/9T/provider.json`  
+    - Linux：`~/.config/9t/provider.json`  
+    - Windows：`%AppData%\\9T\\provider.json`  
+  - 环境变量覆盖：  
+    - `9T_API_KEY`、`9T_BASE_URL`、`9T_MODEL`  
+  - 设备迁移：复制上述配置文件与 `config.json`（含 `allowed_dirs`、`mode`、`workspace`）
+- 命令行接口（建议补充）  
+  - 运行模式：  
+    - `9t` 默认交互模式  
+    - `9t --interactive` 显式交互模式  
+    - `9t --test` 生成 `demo/test.md` 测试任务  
+    - `9t --key-status` 查看 API Key 是否已存储  
+    - `9t "<任务文本>"` 单次执行  
+    - 交互指令：`/tools`、`/?`、`/help`、`/about`、`/keystatus`、`/exit`
+  - 权限相关：  
+    - `9t --mode strict|supervised|open`  
+    - `9t --roots "/Users/me/Documents,/Users/me/Downloads"`  
+    - `9t --workspace "/path/to/workspace"`  
+    - `9t --allow-risk delete`（显式允许高风险工具，逗号分隔）
+- 安全默认与提示  
+  - 首次运行采用 strict + workspace-only  
+  - 用户显式提供 `--roots`/`--mode` 后，命令行回显“授权目录与当前模式”以提示风险  
+  - 对高风险工具在 supervised 模式下必须二次确认（交互式）或通过标志显式允许（非交互式）
+
+## 4. 权限配置细节
+- 配置优先级：CLI 参数 > 环境变量 > 配置文件 > 默认值
+- 配置样例（config.json）
+  - 结构：  
+    - `mode`: `strict|supervised|open`  
+    - `workspace`: 绝对路径  
+    - `allowed_dirs`: 绝对路径数组  
+    - `allow_risk`: `["delete","execute","open"]`
+- 典型配置组合  
+  - 仅 workspace：`mode=strict` + `allowed_dirs=[]`  
+  - 扩展到 Documents/Downloads：`mode=supervised` + `allowed_dirs=[~/Documents, ~/Downloads]`  
+  - 自动化批处理：`mode=open` + 明确 `allowed_dirs` + CI 内运行
+- 交互确认  
+  - supervised 模式在 delete/execute/open 时必须二次确认  
+  - 非交互执行需显式 `--allow-risk`，否则拒绝
+- 软链与越界  
+  - 所有路径需 `realpath` 规范化后再匹配 allowlist  
+  - 任何 `..`、绝对路径、跨盘符需被阻断或转入 ask 流程
+
+## 5. Key 存储与安全
+- 行为  
+  - 若 `9T_API_KEY` 已设置，优先使用  
+  - 否则从系统安全存储读取  
+  - 若仍缺失，提示 `apikey:` 且隐藏输入，回车后写入系统安全存储  
+  - 查询状态：`9t --key-status` 或交互内 `/keystatus`
+- 系统安全存储  
+  - macOS：Keychain（security）  
+  - Linux：libsecret（secret-tool）  
+  - Windows：Credential Manager（CredRead/CredWrite）
+
+## 6. npm 打包发布细节
+- package.json 关键字段  
+  - 位置：`Movevom/package.json`  
+  - `"name": "@movevom/9t"`  
+  - `"type": "module"`  
+  - `"bin": { "9t": "cli-9t/index.mjs" }`
+- 发布流程（组织作用域）
+  - `npm login`  
+  - `npm org ls movevom` 确认账号已加入组织  
+  - 首次发布：`npm publish --access public`  
+  - 版本更新：`npm version patch|minor|major` 后再发布
+- 版本策略  
+  - CLI 行为变更走 minor 或 major  
+  - 配置格式变更必须增加迁移说明
+- 跨平台注意  
+  - 避免依赖平台命令；必要时封装为 Node 实现  
+  - Windows 路径需兼容反斜杠与空格
+
+## 7. 使用场景与建议
+- 仅操作项目目录：使用 strict + workspace-only（默认）  
+- 管理个人资料库（Documents/Downloads）：使用 supervised + 指定 `--roots`，保留二次确认  
+- 自动化脚本/CI 场景：使用 open + 明确 `--roots`，但在受控环境下运行  
+
+## 8. 后续落地清单（不在本次提交中修改代码）
+- 读取并合并多源配置（CLI 参数 > 环境变量 > 配置文件 > 默认）  
+- 在路径解析函数中加入“授权目录集合校验”与“软链逃逸检测”  
+- 引入模式与高风险工具执行前置检查/确认  
+- 输出运行模式与授权目录摘要，便于用户核对  

package/docs/plan/004-gateway.md

@@ -0,0 +1,61 @@
+# 004｜Gateway（网关）与 9T 的结合方案
+
+## 1. Gateway 是什么
+- Gateway 是“统一入口 + 权限边界 + 会话中转”的服务层
+- 作用：在用户、外部渠道与 9T CLI 之间做请求接入、鉴权、路由与审计
+- 目标：把 9T 从“本地 CLI”升级为“可被多端安全调用的能力服务”
+
+## 2. 9T 为什么需要 Gateway
+- 多入口接入：Web、Bot、Webhook、移动端都需要统一入口
+- 安全边界：把密钥、权限、速率、审计放在 CLI 之外
+- 任务编排：把“接入层”与“执行层”解耦，便于扩展
+
+## 3. Gateway 在 9T 的位置
+```
+用户/平台 → Gateway → 9T CLI → 工具执行 → 回写结果
+```
+- Gateway 负责鉴权与路由
+- 9T CLI 专注执行与工具调用
+- 结果回传到 Gateway，再返回用户或外部系统
+
+## 4. 网关的核心功能清单
+- 鉴权：API Key、Token、OAuth、签名校验
+- 速率与成本控制：按用户/项目限流、限额
+- 会话管理：会话 ID、上下文压缩、上下文清理
+- 日志与审计：请求输入、输出摘要、时延、成本
+- 安全策略：敏感命令拦截、黑白名单
+- 路由：按任务类型选择模型或执行后端
+
+## 5. 9T 的 Gateway 方案（建议最小实现）
+- HTTP Gateway（本地或内网服务）
+  - `/health`：健康检查
+  - `/pair`：首次配对，生成会话 token
+  - `/run`：提交任务，返回结果
+- 鉴权策略
+  - 默认只允许 localhost
+  - token 必须在请求头中携带
+- 任务执行策略
+  - Gateway 只负责转发与审计，不直接执行工具
+  - 9T CLI 按当前 workspace 与权限配置执行
+
+## 6. 典型使用场景
+- 本地开发：网页或桌面 UI 通过 Gateway 调用 9T
+- 团队协作：统一入口 + 权限边界，减少 CLI 直连风险
+- 多端接入：Webhook / Bot / Mobile 走同一通道
+
+## 7. 关键安全设计
+- 默认不对公网开放端口
+- 需要显式配对（pair）才能发起任务
+- Gateway 只接受允许的源地址或网关层白名单
+- 所有操作记录日志并可回放
+
+## 8. 与 9T 当前实现的关系
+- 当前 9T 是纯 CLI，本地执行
+- Gateway 作为 Phase1 的可选扩展层
+- 先完成 CLI → 再增加 Gateway → 最后支持 Web/多端
+
+## 9. 后续落地清单
+- 设计最小 Gateway API 协议
+- 确定 token 与配对方式
+- 适配 CLI 的“任务执行入口”
+- 增加审计日志与调用追踪

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@movevom/9t",
+  "version": "0.1.0",
+  "description": "9T CLI tools agent",
+  "type": "module",
+  "bin": {
+    "9t": "cli-9t/index.mjs"
+  },
+  "files": [
+    "cli-9t",
+    "config",
+    "docs"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}