@jiangyuan1209/yuan-claw 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { select, cancel, isCancel } from "@clack/prompts";
+import { initGlobalProxy } from "../lib/initGlobalProxy.js";
+import { parseCliArgs } from "./parse-args.js";
+import { getHelpText } from "./help.js";
+import { resolveWorkspaceRoot } from "../security/path-guards.js";
+import { createToolRegistry } from "../tools/registry.js";
+import { SessionStore } from "../memory/session-store.js";
+import { createConsoleEventBus } from "../events/event-bus.js";
+import { runLocalAgentLoop } from "../agent/run-local-agent-loop.js";
+import { createModelClient } from "../model/client.js";
+import { ensureUserConfigInitialized } from "../config/init-user-config.js";
+import { loadAppConfig } from "../config/load-config.js";
+import { startRepl } from "./repl.js";
+async function requestApprovalFromConsole(message) {
+    const result = await select({
+        message,
+        options: [
+            {
+                value: "deny",
+                label: "不允许",
+                hint: "拒绝这次操作",
+            },
+            {
+                value: "allow-once",
+                label: "允许",
+                hint: "仅允许这一次",
+            },
+            {
+                value: "allow-always",
+                label: "总是允许",
+                hint: "仅当前本次运行/会话有效",
+            },
+        ],
+    });
+    if (isCancel(result)) {
+        cancel("已取消，本次按不允许处理。");
+        console.log("");
+        return "deny";
+    }
+    console.log("");
+    return result;
+}
+async function main() {
+    const args = parseCliArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(getHelpText());
+        return;
+    }
+    const initResult = await ensureUserConfigInitialized();
+    const config = await loadAppConfig();
+    if (initResult.createdSettings) {
+        console.log(`Initialized config file at: ${initResult.settingsPath}`);
+        console.log("Please edit the file and add your model settings if needed.\n");
+    }
+    initGlobalProxy(config);
+    if (!args.userInput) {
+        await startRepl({
+            workspace: args.workspace,
+            model: args.model,
+            json: args.json,
+            quiet: args.quiet,
+            maxSteps: args.maxSteps,
+            config,
+        });
+        return;
+    }
+    const workspaceRoot = resolveWorkspaceRoot(args.workspace ?? process.cwd());
+    const tools = createToolRegistry({
+        workspaceRoot,
+        config,
+    });
+    const sessionStore = new SessionStore();
+    const eventBus = createConsoleEventBus({
+        json: args.json,
+        quiet: args.quiet,
+    });
+    const previousSession = args.sessionId
+        ? await sessionStore.load(args.sessionId)
+        : null;
+    const modelClient = createModelClient({
+        model: args.model,
+        config,
+    });
+    const result = await runLocalAgentLoop({
+        userInput: args.userInput,
+        modelClient,
+        tools,
+        eventBus,
+        maxSteps: args.maxSteps ?? 30,
+        previousMessages: previousSession?.messages ?? [],
+        approvalMode: "ask",
+        requestApproval: requestApprovalFromConsole,
+        onMessagesUpdated: args.sessionId
+            ? async (messages) => {
+                await sessionStore.save(args.sessionId, messages);
+            }
+            : undefined,
+    });
+    if (!args.quiet) {
+        console.log(result.finalMessage);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/cli/parse-args.js

@@ -0,0 +1,75 @@
+export function parseCliArgs(argv) {
+    let sessionId;
+    let workspace;
+    let maxSteps;
+    let model;
+    let json = false;
+    let quiet = false;
+    let help = false;
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--session" || arg === "--session-id") {
+            sessionId = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--session=")) {
+            sessionId = arg.slice("--session=".length);
+            continue;
+        }
+        if (arg.startsWith("--session-id=")) {
+            sessionId = arg.slice("--session-id=".length);
+            continue;
+        }
+        if (arg === "--workspace") {
+            workspace = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--workspace=")) {
+            workspace = arg.slice("--workspace=".length);
+            continue;
+        }
+        if (arg === "--max-steps") {
+            const value = argv[++i];
+            maxSteps = value ? Number(value) : undefined;
+            continue;
+        }
+        if (arg.startsWith("--max-steps=")) {
+            maxSteps = Number(arg.slice("--max-steps=".length));
+            continue;
+        }
+        if (arg === "--model") {
+            model = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            model = arg.slice("--model=".length);
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--quiet") {
+            quiet = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+            continue;
+        }
+        positional.push(arg);
+    }
+    return {
+        userInput: positional.join(" ").trim(),
+        sessionId,
+        workspace,
+        maxSteps: typeof maxSteps === "number" && Number.isFinite(maxSteps)
+            ? maxSteps
+            : undefined,
+        model,
+        json,
+        quiet,
+        help,
+    };
+}

package/dist/cli/repl.js

@@ -0,0 +1,188 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import crypto from "node:crypto";
+import { resolveWorkspaceRoot } from "../security/path-guards.js";
+import { createToolRegistry } from "../tools/registry.js";
+import { SessionStore } from "../memory/session-store.js";
+import { createConsoleEventBus } from "../events/event-bus.js";
+import { runLocalAgentLoop, } from "../agent/run-local-agent-loop.js";
+import { createModelClient } from "../model/client.js";
+function approvalLabel(decision) {
+    switch (decision) {
+        case "deny":
+            return "不允许";
+        case "allow-once":
+            return "允许";
+        case "allow-always":
+            return "总是允许";
+    }
+}
+function printApprovalMenu(message, selectedIndex) {
+    const options = [
+        { label: "不允许", hint: "拒绝这次操作" },
+        { label: "允许", hint: "仅允许这一次" },
+        { label: "总是允许", hint: "当前会话后续 confirm / dangerous 操作自动允许" },
+    ];
+    output.write(`\n${message}\n\n`);
+    output.write("使用 ↑ / ↓ 切换，Enter 确认，Ctrl+C 拒绝\n\n");
+    for (let i = 0; i < options.length; i += 1) {
+        const prefix = i === selectedIndex ? "❯" : " ";
+        output.write(`${prefix} ${options[i].label}  ${options[i].hint}\n`);
+    }
+    output.write("\n");
+}
+async function selectApprovalWithArrows(message) {
+    const values = ["deny", "allow-once", "allow-always"];
+    let selectedIndex = 1;
+    return await new Promise((resolve) => {
+        const cleanup = () => {
+            input.off("data", onData);
+            if (input.isTTY) {
+                input.setRawMode(false);
+            }
+        };
+        const onData = (buffer) => {
+            const key = buffer.toString("utf8");
+            if (key === "\u0003") {
+                cleanup();
+                output.write("\n");
+                resolve("deny");
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                const result = values[selectedIndex];
+                cleanup();
+                output.write(`已选择：${approvalLabel(result)}\n\n`);
+                resolve(result);
+                return;
+            }
+            if (key === "\u001b[A") {
+                selectedIndex =
+                    selectedIndex === 0 ? values.length - 1 : selectedIndex - 1;
+                printApprovalMenu(message, selectedIndex);
+                return;
+            }
+            if (key === "\u001b[B") {
+                selectedIndex =
+                    selectedIndex === values.length - 1 ? 0 : selectedIndex + 1;
+                printApprovalMenu(message, selectedIndex);
+            }
+        };
+        if (output.isTTY) {
+            output.write("\x1b[2K\r");
+        }
+        if (input.isTTY) {
+            input.setRawMode(true);
+        }
+        input.resume();
+        input.on("data", onData);
+        printApprovalMenu(message, selectedIndex);
+    });
+}
+export async function startRepl(options) {
+    const rl = readline.createInterface({ input, output });
+    const sessionStore = new SessionStore();
+    const sessionId = crypto.randomUUID();
+    const workspaceRoot = resolveWorkspaceRoot(options.workspace ?? process.cwd());
+    const tools = createToolRegistry({
+        workspaceRoot,
+        config: options.config,
+    });
+    const modelClient = createModelClient({
+        model: options.model,
+        config: options.config,
+    });
+    let messages = [];
+    let approvalMode = "ask";
+    async function requestApproval(message) {
+        const result = await selectApprovalWithArrows(message);
+        console.log("");
+        return result;
+    }
+    console.log("Welcome to Yuan Claw!");
+    console.log("Type /help for commands, /exit to quit.");
+    console.log("Approval mode is shown in the prompt: [ask] or [always].\n");
+    while (true) {
+        let line;
+        try {
+            const promptLabel = approvalMode === "always-allow"
+                ? "yuan-claw[always]> "
+                : "yuan-claw[ask]> ";
+            line = await rl.question(promptLabel);
+        }
+        catch {
+            console.log("\nBye!");
+            break;
+        }
+        const userInput = line.trim();
+        if (!userInput) {
+            continue;
+        }
+        if (userInput === "/exit" || userInput === "/quit") {
+            console.log("Bye!");
+            break;
+        }
+        if (userInput === "/help") {
+            console.log(`
+Commands:
+  /help    Show help
+  /exit    Exit
+  /quit    Exit
+  /clear   Clear current session history and reset approval mode
+  /save    Save current session
+  /reset   Reset approval mode to ask
+  /status  Show current session status
+`);
+            continue;
+        }
+        if (userInput === "/clear") {
+            messages = [];
+            approvalMode = "ask";
+            console.log("Session history cleared. Approval mode reset to ask.");
+            continue;
+        }
+        if (userInput === "/save") {
+            await sessionStore.save(sessionId, messages);
+            console.log(`Session saved: ${sessionId}`);
+            continue;
+        }
+        if (userInput === "/reset") {
+            approvalMode = "ask";
+            console.log("Approval mode reset to ask.");
+            continue;
+        }
+        if (userInput === "/status") {
+            console.log(`sessionId: ${sessionId}`);
+            console.log(`approvalMode: ${approvalMode}`);
+            console.log(`messageCount: ${messages.length}`);
+            continue;
+        }
+        const eventBus = createConsoleEventBus({
+            json: options.json,
+            quiet: options.quiet,
+        });
+        try {
+            const result = await runLocalAgentLoop({
+                userInput,
+                modelClient,
+                tools,
+                eventBus,
+                maxSteps: options.maxSteps ?? 30,
+                previousMessages: messages,
+                approvalMode,
+                requestApproval,
+                onMessagesUpdated: async (updatedMessages) => {
+                    messages = updatedMessages;
+                },
+            });
+            approvalMode = result.approvalMode;
+            if (!options.quiet) {
+                console.log(result.finalMessage);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    rl.close();
+}

package/dist/config/config-path.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+import path from "node:path";
+export const MY_AGENT_DIR_NAME = ".yuan-claw";
+export function getUserConfigDir() {
+    return path.join(os.homedir(), MY_AGENT_DIR_NAME);
+}
+export function getUserSettingsPath() {
+    return path.join(getUserConfigDir(), "settings.json");
+}

package/dist/config/init-user-config.js

@@ -0,0 +1,39 @@
+import fs from "node:fs/promises";
+import { getUserConfigDir, getUserSettingsPath } from "./config-path.js";
+const DEFAULT_SETTINGS = {
+    MODEL_API_KEY: "",
+    MODEL_BASE_URL: "",
+    MODEL_NAME: "gpt-4o-mini",
+    OPENAI_API_KEY: "",
+    OPENAI_BASE_URL: "",
+    OPENAI_MODEL: "",
+    BRAVE_SEARCH_API_KEY: "",
+    BRAVE_API_KEY: "",
+    HTTP_PROXY: "",
+    HTTPS_PROXY: "",
+};
+export async function ensureUserConfigInitialized() {
+    const configDir = getUserConfigDir();
+    const settingsPath = getUserSettingsPath();
+    let createdDir = false;
+    let createdSettings = false;
+    try {
+        await fs.mkdir(configDir, { recursive: true });
+        createdDir = true;
+    }
+    catch {
+        // ignore
+    }
+    try {
+        await fs.access(settingsPath);
+    }
+    catch {
+        await fs.writeFile(settingsPath, JSON.stringify(DEFAULT_SETTINGS, null, 2) + "\n", "utf-8");
+        createdSettings = true;
+    }
+    return {
+        createdDir,
+        createdSettings,
+        settingsPath,
+    };
+}

package/dist/config/load-config.js

@@ -0,0 +1,46 @@
+import fs from "node:fs/promises";
+import { z } from "zod";
+import { getUserSettingsPath } from "./config-path.js";
+const userSettingsSchema = z.object({
+    MODEL_API_KEY: z.string().optional(),
+    MODEL_BASE_URL: z.string().optional(),
+    MODEL_NAME: z.string().optional(),
+    OPENAI_API_KEY: z.string().optional(),
+    OPENAI_BASE_URL: z.string().optional(),
+    OPENAI_MODEL: z.string().optional(),
+    BRAVE_SEARCH_API_KEY: z.string().optional(),
+    BRAVE_API_KEY: z.string().optional(),
+    HTTP_PROXY: z.string().optional(),
+    HTTPS_PROXY: z.string().optional(),
+    http_proxy: z.string().optional(),
+    https_proxy: z.string().optional(),
+});
+async function loadSettingsFile() {
+    const settingsPath = getUserSettingsPath();
+    try {
+        const raw = await fs.readFile(settingsPath, "utf-8");
+        const json = JSON.parse(raw);
+        return userSettingsSchema.parse(json);
+    }
+    catch {
+        return {};
+    }
+}
+export async function loadAppConfig() {
+    const fileConfig = await loadSettingsFile();
+    return {
+        ...fileConfig,
+        MODEL_API_KEY: process.env.MODEL_API_KEY ?? fileConfig.MODEL_API_KEY,
+        MODEL_BASE_URL: process.env.MODEL_BASE_URL ?? fileConfig.MODEL_BASE_URL,
+        MODEL_NAME: process.env.MODEL_NAME ?? fileConfig.MODEL_NAME,
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY ?? fileConfig.OPENAI_API_KEY,
+        OPENAI_BASE_URL: process.env.OPENAI_BASE_URL ?? fileConfig.OPENAI_BASE_URL,
+        OPENAI_MODEL: process.env.OPENAI_MODEL ?? fileConfig.OPENAI_MODEL,
+        BRAVE_SEARCH_API_KEY: process.env.BRAVE_SEARCH_API_KEY ?? fileConfig.BRAVE_SEARCH_API_KEY,
+        BRAVE_API_KEY: process.env.BRAVE_API_KEY ?? fileConfig.BRAVE_API_KEY,
+        HTTP_PROXY: process.env.HTTP_PROXY ?? fileConfig.HTTP_PROXY,
+        HTTPS_PROXY: process.env.HTTPS_PROXY ?? fileConfig.HTTPS_PROXY,
+        http_proxy: process.env.http_proxy ?? fileConfig.http_proxy,
+        https_proxy: process.env.https_proxy ?? fileConfig.https_proxy,
+    };
+}

package/dist/config.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+export function loadConfig() {
+    const configPath = path.resolve(process.cwd(), "my-agent.config.json");
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    const config = JSON.parse(raw);
+    if (!config.model?.baseURL) {
+        throw new Error("config.model.baseURL is required");
+    }
+    if (!config.model?.apiKey) {
+        throw new Error("config.model.apiKey is required");
+    }
+    if (!config.model?.model) {
+        throw new Error("config.model.model is required");
+    }
+    if (!config.agent?.sessionId) {
+        throw new Error("config.agent.sessionId is required");
+    }
+    if (!config.agent?.maxSteps) {
+        throw new Error("config.agent.maxSteps is required");
+    }
+    if (!config.agent?.workspace) {
+        throw new Error("config.agent.workspace is required");
+    }
+    return config;
+}

package/dist/events/event-bus.js

@@ -0,0 +1,62 @@
+function printToolResultPreview(result) {
+    try {
+        const preview = JSON.stringify(result, null, 2);
+        console.log(preview.slice(0, 800) + (preview.length > 800 ? "\n...[truncated]" : ""));
+    }
+    catch {
+        console.log(String(result));
+    }
+}
+export function createConsoleEventBus(options = {}) {
+    const json = options.json ?? false;
+    const quiet = options.quiet ?? false;
+    return {
+        emit(event) {
+            if (json) {
+                console.log(JSON.stringify(event));
+                return;
+            }
+            if (quiet) {
+                if (event.type === "assistant") {
+                    console.log(event.message);
+                }
+                if (event.type === "run_error") {
+                    console.error(`[run_error] ${event.stage}: ${event.error}`);
+                }
+                return;
+            }
+            switch (event.type) {
+                case "run_start":
+                    console.log(`\n[run_start] ${event.input}`);
+                    break;
+                case "model_raw":
+                    console.log(`\n[model_raw] step=${event.step}`);
+                    console.log(event.text);
+                    break;
+                case "tool_start":
+                    console.log(`\n[tool_start] ${event.toolName}`);
+                    console.log(JSON.stringify(event.args, null, 2));
+                    break;
+                case "tool_end":
+                    console.log(`\n[tool_end] ${event.toolName} success=${event.success}`);
+                    printToolResultPreview(event.result);
+                    break;
+                case "tool_error":
+                    console.log(`\n[tool_error] ${event.toolName}`);
+                    console.log(event.error);
+                    break;
+                case "assistant":
+                    console.log(`\n[assistant]`);
+                    console.log(event.message);
+                    break;
+                case "run_error":
+                    console.log(`\n[run_error] stage=${event.stage} step=${event.step}`);
+                    console.log(event.error);
+                    break;
+                case "run_end":
+                    console.log(`\n[run_end] reason=${event.reason} step=${event.step}`);
+                    break;
+            }
+        },
+    };
+}

package/dist/lib/initGlobalProxy.js

@@ -0,0 +1,52 @@
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+let proxyInitialized = false;
+function resolveProxyUrl(config) {
+    return (config?.HTTPS_PROXY ||
+        config?.HTTP_PROXY ||
+        config?.https_proxy ||
+        config?.http_proxy ||
+        process.env.HTTPS_PROXY ||
+        process.env.HTTP_PROXY ||
+        process.env.https_proxy ||
+        process.env.http_proxy);
+}
+function maskProxyForLog(proxyUrl) {
+    try {
+        const url = new URL(proxyUrl);
+        if (url.username || url.password) {
+            url.username = url.username ? "***" : "";
+            url.password = url.password ? "***" : "";
+        }
+        return url.toString();
+    }
+    catch {
+        return proxyUrl;
+    }
+}
+/**
+ * 初始化 Node/undici 全局代理。
+ *
+ * 优先级：
+ * 1. 传入的 config
+ * 2. process.env
+ */
+export function initGlobalProxy(config) {
+    if (proxyInitialized) {
+        return;
+    }
+    const proxyUrl = resolveProxyUrl(config);
+    if (!proxyUrl) {
+        console.log("[proxy] not configured, using direct connection");
+        proxyInitialized = true;
+        return;
+    }
+    try {
+        setGlobalDispatcher(new ProxyAgent(proxyUrl));
+        proxyInitialized = true;
+        console.log(`[proxy] using ${maskProxyForLog(proxyUrl)}`);
+    }
+    catch (error) {
+        console.error("[proxy] failed to initialize global proxy:", error);
+        throw error;
+    }
+}

package/dist/memory/session-store.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { trimMessages } from "../agent/message-utils.js";
+export class SessionStore {
+    baseDir;
+    constructor(options = {}) {
+        this.baseDir = options.baseDir ?? path.resolve(".sessions");
+    }
+    getFilePath(sessionId) {
+        return path.join(this.baseDir, `${sessionId}.json`);
+    }
+    async load(sessionId) {
+        try {
+            const filePath = this.getFilePath(sessionId);
+            const text = await fs.readFile(filePath, "utf8");
+            return JSON.parse(text);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("ENOENT")) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async save(sessionId, messages) {
+        await fs.mkdir(this.baseDir, { recursive: true });
+        const persistedMessages = trimMessages(messages.filter((m) => m.role !== "system"), {
+            maxMessages: 24,
+            maxTotalChars: 8000,
+            preserveRecentMessages: 6,
+            preserveSystemMessages: false,
+            compactToolMessages: true,
+        });
+        const data = {
+            sessionId,
+            messages: persistedMessages,
+            updatedAt: new Date().toISOString(),
+        };
+        const filePath = this.getFilePath(sessionId);
+        await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+    }
+}

package/dist/memory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/client.js

@@ -0,0 +1,7 @@
+import { createOpenAICompatibleClient } from "./providers/openai-compatible.js";
+export function createModelClient(options = {}) {
+    return createOpenAICompatibleClient({
+        model: options.model,
+        config: options.config,
+    });
+}