@jiangyuan1209/yuan-claw 0.1.0

package/dist/agent/message-utils.js

@@ -0,0 +1,239 @@
+const DEFAULT_TEXT_MAX_CHARS = 4_000;
+const DEFAULT_TEXT_HEAD_CHARS = 2_500;
+const DEFAULT_TEXT_TAIL_CHARS = 1_000;
+const DEFAULT_TEXT_MARKER = "\n...[truncated]...\n";
+const DEFAULT_VALUE_MAX_STRING_CHARS = 4_000;
+const DEFAULT_VALUE_MAX_ARRAY_ITEMS = 20;
+const DEFAULT_VALUE_MAX_OBJECT_KEYS = 40;
+const DEFAULT_VALUE_MAX_DEPTH = 6;
+const DEFAULT_MAX_MESSAGES = 24;
+const DEFAULT_MAX_TOTAL_CHARS = 24_000;
+const DEFAULT_PRESERVE_RECENT_MESSAGES = 8;
+export function truncateText(text, options = {}) {
+    const maxChars = options.maxChars ?? DEFAULT_TEXT_MAX_CHARS;
+    const headChars = options.headChars ?? DEFAULT_TEXT_HEAD_CHARS;
+    const tailChars = options.tailChars ?? DEFAULT_TEXT_TAIL_CHARS;
+    const marker = options.marker ?? DEFAULT_TEXT_MARKER;
+    const totalChars = text.length;
+    if (totalChars <= maxChars) {
+        return {
+            text,
+            truncated: false,
+            totalChars,
+            returnedChars: totalChars,
+        };
+    }
+    const safeHead = Math.max(0, headChars);
+    const safeTail = Math.max(0, tailChars);
+    let next = text.slice(0, safeHead) + marker;
+    if (safeTail > 0) {
+        next += text.slice(-safeTail);
+    }
+    if (next.length > maxChars) {
+        next = next.slice(0, maxChars);
+    }
+    return {
+        text: next,
+        truncated: true,
+        totalChars,
+        returnedChars: next.length,
+    };
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compactValueInternal(value, options, depth) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        if (typeof value === "string") {
+            const truncated = truncateText(value, {
+                maxChars: options.maxStringChars,
+            });
+            return truncated.text;
+        }
+        return value;
+    }
+    if (depth >= options.maxDepth) {
+        return "[MaxDepthExceeded]";
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, options.maxArrayItems)
+            .map((item) => compactValueInternal(item, options, depth + 1));
+        if (value.length > options.maxArrayItems) {
+            items.push(`[... ${value.length - options.maxArrayItems} more items omitted]`);
+        }
+        return items;
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.entries(value);
+        const limitedEntries = entries.slice(0, options.maxObjectKeys);
+        const result = {};
+        for (const [key, val] of limitedEntries) {
+            result[key] = compactValueInternal(val, options, depth + 1);
+        }
+        if (entries.length > options.maxObjectKeys) {
+            result.__omittedKeys = entries.length - options.maxObjectKeys;
+        }
+        return result;
+    }
+    return String(value);
+}
+export function compactValue(value, options = {}) {
+    return compactValueInternal(value, {
+        maxStringChars: options.maxStringChars ?? DEFAULT_VALUE_MAX_STRING_CHARS,
+        maxArrayItems: options.maxArrayItems ?? DEFAULT_VALUE_MAX_ARRAY_ITEMS,
+        maxObjectKeys: options.maxObjectKeys ?? DEFAULT_VALUE_MAX_OBJECT_KEYS,
+        maxDepth: options.maxDepth ?? DEFAULT_VALUE_MAX_DEPTH,
+    }, 0);
+}
+export function compactToolResult(result, options = {}) {
+    return compactValue(result, options);
+}
+export function compactAssistantToolCall(content) {
+    const truncated = truncateText(content, {
+        maxChars: 800,
+        headChars: 600,
+        tailChars: 120,
+    });
+    return truncated.truncated
+        ? `[assistant tool call summary]\n${truncated.text}`
+        : content;
+}
+function estimateMessageChars(message) {
+    const content = typeof message.content === "string"
+        ? message.content
+        : JSON.stringify(message.content ?? "");
+    return content.length + message.role.length;
+}
+function compactMessage(message) {
+    const content = typeof message.content === "string"
+        ? message.content
+        : JSON.stringify(message.content ?? "");
+    if (message.role === "tool") {
+        return {
+            ...message,
+            content: JSON.stringify(compactToolResult(safeJsonParse(content) ?? content)),
+        };
+    }
+    if (message.role === "assistant") {
+        return {
+            ...message,
+            content: compactAssistantToolCall(content),
+        };
+    }
+    if (message.role === "user") {
+        const truncated = truncateText(content, {
+            maxChars: 2_000,
+            headChars: 1_400,
+            tailChars: 300,
+        });
+        return {
+            ...message,
+            content: truncated.text,
+        };
+    }
+    if (message.role === "system") {
+        const truncated = truncateText(content, {
+            maxChars: 3_000,
+            headChars: 2_400,
+            tailChars: 300,
+        });
+        return {
+            ...message,
+            content: truncated.text,
+        };
+    }
+    return message;
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export function trimMessages(messages, options = {}) {
+    const maxMessages = options.maxMessages ?? DEFAULT_MAX_MESSAGES;
+    const maxTotalChars = options.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
+    const preserveSystemMessages = options.preserveSystemMessages ?? true;
+    const preserveRecentMessages = options.preserveRecentMessages ?? DEFAULT_PRESERVE_RECENT_MESSAGES;
+    const compactToolMessages = options.compactToolMessages ?? true;
+    if (messages.length === 0) {
+        return [];
+    }
+    const systemMessages = preserveSystemMessages
+        ? messages.filter((m) => m.role === "system")
+        : [];
+    const nonSystemMessages = preserveSystemMessages
+        ? messages.filter((m) => m.role !== "system")
+        : [...messages];
+    const recent = nonSystemMessages.slice(-preserveRecentMessages);
+    const older = nonSystemMessages.slice(0, Math.max(0, nonSystemMessages.length - preserveRecentMessages));
+    const compactedOlder = older.map((message) => {
+        if (compactToolMessages || message.role !== "tool") {
+            return compactMessage(message);
+        }
+        return message;
+    });
+    let result = [...systemMessages, ...compactedOlder, ...recent];
+    if (result.length > maxMessages) {
+        const preservedSystem = result.filter((m) => m.role === "system");
+        const others = result.filter((m) => m.role !== "system");
+        result = [...preservedSystem, ...others.slice(-(maxMessages - preservedSystem.length))];
+    }
+    let totalChars = result.reduce((sum, message) => sum + estimateMessageChars(message), 0);
+    if (totalChars <= maxTotalChars) {
+        return result;
+    }
+    const finalMessages = [];
+    const systems = result.filter((m) => m.role === "system");
+    const others = result.filter((m) => m.role !== "system");
+    for (const msg of systems) {
+        finalMessages.push(compactMessage(msg));
+    }
+    for (const msg of others.slice(-preserveRecentMessages)) {
+        finalMessages.push(compactMessage(msg));
+    }
+    totalChars = finalMessages.reduce((sum, message) => sum + estimateMessageChars(message), 0);
+    if (totalChars <= maxTotalChars) {
+        return finalMessages;
+    }
+    const trimmed = [];
+    let running = 0;
+    for (const msg of [...systems, ...others].reverse()) {
+        const compacted = compactMessage(msg);
+        const size = estimateMessageChars(compacted);
+        if (running + size > maxTotalChars) {
+            continue;
+        }
+        trimmed.push(compacted);
+        running += size;
+    }
+    return trimmed.reverse();
+}
+export function prepareMessagesForModel(messages, options = {}) {
+    return trimMessages(messages, options);
+}
+export function serializeToolMessage(result) {
+    const compacted = compactToolResult(result);
+    if (compacted && typeof compacted === "object" && !Array.isArray(compacted)) {
+        return JSON.stringify({
+            ...compacted,
+            _meta: {
+                note: "Tool output may be compacted or truncated. If visibility is partial, say so explicitly.",
+            },
+        }, null, 2);
+    }
+    return JSON.stringify({
+        value: compacted,
+        _meta: {
+            note: "Tool output may be compacted or truncated. If visibility is partial, say so explicitly.",
+        },
+    }, null, 2);
+}

package/dist/agent/parse-agent-response.js

@@ -0,0 +1,48 @@
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function parseAgentResponse(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Agent response is not valid JSON.");
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error("Agent response must be a JSON object.");
+    }
+    const type = parsed.type;
+    if (type === "tool_call") {
+        if (typeof parsed.toolName !== "string" || parsed.toolName.trim() === "") {
+            throw new Error('tool_call response must include a non-empty string field "toolName".');
+        }
+        if (!isPlainObject(parsed.args)) {
+            throw new Error('tool_call response must include an object field "args".');
+        }
+        return {
+            type: "tool_call",
+            toolName: parsed.toolName,
+            args: parsed.args,
+        };
+    }
+    if (type === "final") {
+        if (typeof parsed.message !== "string") {
+            throw new Error('final response must include a string field "message".');
+        }
+        return {
+            type: "final",
+            message: parsed.message,
+        };
+    }
+    if (type === "ask_confirmation") {
+        if (typeof parsed.message !== "string" || parsed.message.trim() === "") {
+            throw new Error('ask_confirmation response must include a non-empty string field "message".');
+        }
+        return {
+            type: "ask_confirmation",
+            message: parsed.message,
+        };
+    }
+    throw new Error(`Unsupported agent response type: ${String(type)}`);
+}

package/dist/agent/prompts.js

@@ -0,0 +1,27 @@
+export function buildToolsPrompt(tools) {
+    return Array.from(tools.values())
+        .map((tool) => `- ${tool.name}: ${tool.description}`)
+        .join("\n");
+}
+export function makeSystemPrompt(tools) {
+    return [
+        "You are a local coding agent.",
+        "You may use tools to inspect files, run commands, inspect git state, fetch web content, and complete tasks.",
+        "You must respond with exactly one JSON object and nothing else.",
+        'Use {"type":"final","message":"..."} for final answers.',
+        'Use {"type":"tool_call","toolName":"...","args":{}} for tool calls.',
+        "Call only one tool at a time.",
+        "Prefer using tools when the task requires checking files, git state, commands, or web content.",
+        "If you need repository status, use git_status.",
+        "If you need concrete code changes, use git_diff.",
+        "If you need file contents, use read_file.",
+        "Do not infer exact filenames, renames, code edits, or configuration details unless they appear in tool output or prior messages.",
+        "When tool output is incomplete or truncated, explicitly say the information may be incomplete.",
+        "Distinguish observed facts from tentative inferences.",
+        "Only make claims supported by tool outputs or prior messages.",
+        "Final answers must be in Simplified Chinese unless the user explicitly asks for another language.",
+        "",
+        "Available tools:",
+        buildToolsPrompt(tools),
+    ].join("\n");
+}

package/dist/agent/protocol.js

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

package/dist/agent/read-approval.js

@@ -0,0 +1,45 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+function printApprovalMenu(message) {
+    console.log(message);
+    console.log("");
+    console.log("请选择：");
+    console.log("  1) 不允许");
+    console.log("  2) 允许");
+    console.log("  3) 总是允许");
+    console.log("");
+}
+function normalizeAnswer(answer) {
+    const value = answer.trim().toLowerCase();
+    if (value === "1" || value === "n" || value === "no") {
+        return "deny";
+    }
+    if (value === "2" || value === "y" || value === "yes") {
+        return "allow-once";
+    }
+    if (value === "3" ||
+        value === "a" ||
+        value === "always" ||
+        value === "always-allow") {
+        return "allow-always";
+    }
+    return null;
+}
+export async function readApproval(message) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (true) {
+            printApprovalMenu(message);
+            const answer = await rl.question("输入 1/2/3: ");
+            const decision = normalizeAnswer(answer);
+            if (decision) {
+                console.log("");
+                return decision;
+            }
+            console.log("无效输入，请输入 1、2 或 3。\n");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/agent/read-confirmation.js

@@ -0,0 +1,17 @@
+import readline from "node:readline";
+export async function readConfirmation(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(`${message} [y/N] `, resolve);
+        });
+        const normalized = answer.trim().toLowerCase();
+        return normalized === "y" || normalized === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/agent/run-local-agent-loop.js

@@ -0,0 +1,272 @@
+import { buildSystemPrompt } from "./build-system-prompt.js";
+import { parseAgentResponse } from "./parse-agent-response.js";
+function stringifyForModel(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function trimText(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, maxChars)}\n...[truncated]`;
+}
+function formatToolResultForModel(result, maxChars = 12000) {
+    return trimText(stringifyForModel(result), maxChars);
+}
+async function persistMessages(messages, onMessagesUpdated) {
+    if (onMessagesUpdated) {
+        await onMessagesUpdated(messages);
+    }
+}
+export async function runLocalAgentLoop(params) {
+    const { userInput, modelClient, tools, eventBus, maxSteps = 8, previousMessages = [], onMessagesUpdated, requestApproval, } = params;
+    let approvalMode = params.approvalMode ?? "ask";
+    let allowOneHighRiskToolCall = approvalMode === "always-allow";
+    eventBus.emit({
+        type: "run_start",
+        input: userInput,
+    });
+    const historyMessages = previousMessages.filter((message) => message.role !== "system");
+    const messages = [
+        {
+            role: "system",
+            content: buildSystemPrompt(Array.from(tools.values())),
+        },
+        ...historyMessages,
+        {
+            role: "user",
+            content: userInput,
+        },
+    ];
+    await persistMessages(messages, onMessagesUpdated);
+    for (let step = 1; step <= maxSteps; step += 1) {
+        let rawOutput;
+        try {
+            rawOutput = await modelClient.generate(messages);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            eventBus.emit({
+                type: "run_error",
+                step,
+                stage: "model_generate",
+                error: errorMessage,
+            });
+            throw error;
+        }
+        eventBus.emit({
+            type: "model_raw",
+            text: rawOutput,
+            step,
+        });
+        messages.push({
+            role: "assistant",
+            content: rawOutput,
+        });
+        await persistMessages(messages, onMessagesUpdated);
+        let response;
+        try {
+            response = parseAgentResponse(rawOutput);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            eventBus.emit({
+                type: "run_error",
+                step,
+                stage: "parse_agent_response",
+                error: errorMessage,
+            });
+            messages.push({
+                role: "user",
+                content: [
+                    "Your previous response could not be parsed.",
+                    `Parse error: ${errorMessage}`,
+                    "You must respond with exactly one valid JSON object.",
+                    'Allowed formats:',
+                    '- {"type":"tool_call","toolName":"<tool>","args":{}}',
+                    '- {"type":"final","message":"<answer>"}',
+                    '- {"type":"ask_confirmation","message":"<question>"}',
+                ].join("\n"),
+            });
+            await persistMessages(messages, onMessagesUpdated);
+            continue;
+        }
+        if (response.type === "final") {
+            eventBus.emit({
+                type: "assistant",
+                message: response.message,
+            });
+            eventBus.emit({
+                type: "run_end",
+                reason: "final",
+                step,
+            });
+            return {
+                finalMessage: response.message,
+                approvalMode,
+            };
+        }
+        if (response.type === "ask_confirmation") {
+            let decision;
+            try {
+                if (approvalMode === "always-allow") {
+                    decision = "allow-once";
+                }
+                else if (requestApproval) {
+                    decision = await requestApproval(response.message);
+                }
+                else {
+                    decision = "deny";
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                eventBus.emit({
+                    type: "run_error",
+                    step,
+                    stage: "confirmation",
+                    error: errorMessage,
+                });
+                throw error;
+            }
+            if (decision === "allow-always") {
+                approvalMode = "always-allow";
+                allowOneHighRiskToolCall = true;
+                console.log("已启用“总是允许”模式，本会话后续 confirm / dangerous 操作将自动执行。输入 /reset 可恢复逐次确认。\n");
+            }
+            else if (decision === "allow-once") {
+                allowOneHighRiskToolCall = true;
+            }
+            else {
+                allowOneHighRiskToolCall = false;
+            }
+            messages.push({
+                role: "user",
+                content: decision === "deny"
+                    ? `The user denied your request: ${response.message}. Do not perform that action. Offer a safer alternative or stop.`
+                    : decision === "allow-always"
+                        ? `The user approved your request and enabled always-allow mode for this session: ${response.message}`
+                        : `The user approved your request: ${response.message}`,
+            });
+            await persistMessages(messages, onMessagesUpdated);
+            continue;
+        }
+        if (response.type === "tool_call") {
+            const tool = tools.get(response.toolName);
+            if (!tool) {
+                const errorMessage = `Unknown tool "${response.toolName}".`;
+                eventBus.emit({
+                    type: "tool_error",
+                    toolName: response.toolName,
+                    error: errorMessage,
+                    step,
+                });
+                messages.push({
+                    role: "user",
+                    content: [
+                        `Tool execution failed: ${errorMessage}`,
+                        "Use only the available tools listed in the system prompt.",
+                    ].join("\n"),
+                });
+                await persistMessages(messages, onMessagesUpdated);
+                continue;
+            }
+            const needsConfirmation = tool.riskLevel === "confirm" || tool.riskLevel === "dangerous";
+            if (needsConfirmation &&
+                approvalMode !== "always-allow" &&
+                !allowOneHighRiskToolCall) {
+                const errorMessage = `Tool "${tool.name}" requires confirmation before execution. Ask for confirmation first.`;
+                eventBus.emit({
+                    type: "tool_error",
+                    toolName: response.toolName,
+                    error: errorMessage,
+                    step,
+                });
+                messages.push({
+                    role: "user",
+                    content: [
+                        errorMessage,
+                        "Do not execute this tool yet.",
+                        "Ask the user for confirmation first.",
+                    ].join("\n"),
+                });
+                await persistMessages(messages, onMessagesUpdated);
+                continue;
+            }
+            eventBus.emit({
+                type: "tool_start",
+                toolName: response.toolName,
+                args: response.args,
+                step,
+            });
+            let result;
+            try {
+                result = await tool.execute(response.args);
+                if (needsConfirmation && approvalMode !== "always-allow") {
+                    allowOneHighRiskToolCall = false;
+                }
+            }
+            catch (error) {
+                if (needsConfirmation && approvalMode !== "always-allow") {
+                    allowOneHighRiskToolCall = false;
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                eventBus.emit({
+                    type: "tool_error",
+                    toolName: response.toolName,
+                    error: errorMessage,
+                    step,
+                });
+                messages.push({
+                    role: "user",
+                    content: [
+                        `Tool "${response.toolName}" crashed.`,
+                        `Error: ${errorMessage}`,
+                        "Revise your plan. You may call another tool or return a final response.",
+                    ].join("\n"),
+                });
+                await persistMessages(messages, onMessagesUpdated);
+                continue;
+            }
+            eventBus.emit({
+                type: "tool_end",
+                toolName: response.toolName,
+                success: result.success,
+                result: result.success ? result.output : result.error,
+                step,
+            });
+            if (result.success) {
+                messages.push({
+                    role: "user",
+                    content: [
+                        `Tool "${response.toolName}" completed successfully.`,
+                        `Result: ${formatToolResultForModel(result.output)}`,
+                        "Continue the task. If it is complete, return a final response.",
+                    ].join("\n"),
+                });
+                await persistMessages(messages, onMessagesUpdated);
+                continue;
+            }
+            messages.push({
+                role: "user",
+                content: [
+                    `Tool "${response.toolName}" failed.`,
+                    `Error: ${result.error}`,
+                    "Revise your plan. You may call another tool or return a final response.",
+                ].join("\n"),
+            });
+            await persistMessages(messages, onMessagesUpdated);
+            continue;
+        }
+    }
+    eventBus.emit({
+        type: "run_end",
+        reason: "max_steps_exceeded",
+        step: maxSteps,
+    });
+    throw new Error(`Agent loop exceeded maximum number of steps (${maxSteps}).`);
+}

package/dist/cli/help.js

@@ -0,0 +1,24 @@
+export function getHelpText() {
+    return `
+my-agent - local CLI coding agent
+
+Usage:
+  npm run dev -- [options] "your task"
+  npm run start -- [options] "your task"
+
+Options:
+  --session <id>        Use a persistent session id
+  --workspace <path>    Set workspace root
+  --max-steps <n>       Limit agent loop steps
+  --model <name>        Override model name
+  --json                Output events as JSON lines
+  --quiet               Reduce console output
+  --help, -h            Show help
+
+Examples:
+  npm run dev -- "read package.json"
+  npm run dev -- --session demo "what do you know about this project?"
+  npm run dev -- --max-steps 4 "show git diff and summarize changes"
+  npm run dev -- --json "read tsconfig.json"
+`.trim();
+}