@qlingzzy/qling 1.0.0

package/dist/tools/patch.js

@@ -0,0 +1,458 @@
+import { readFile, writeFile } from "fs/promises";
+import { relative } from "path";
+import { getErrorMessage, toolError, toolSuccess } from "./error-utils.js";
+import { checkSensitiveWriteTarget, getRuntimeRootsFromEnv, isPathAllowedForWrite, resolveToolPath, } from "../runtime-paths.js";
+/** 超过该字节数拒绝做 LCS diff / 写入，防止超大文件 OOM */
+export const PATCH_MAX_FILE_BYTES = 2 * 1024 * 1024;
+export const patchTool = {
+    name: "patch",
+    description: "Apply precise search-and-replace edits (chunks) to an existing file. Only writes if all chunks uniquely match. Supports dry_run. Prefer larger unique context blocks.",
+    longDescription: `精准局部替换文件内容（补丁）。默认会修改磁盘文件；dry_run=true 时只校验并返回 diff。
+
+**使用场景**:
+- 修改文件中的一个或多个函数、变量定义、导入声明等
+- 避免重写大文件以节省 Token 资源并提高修改准确率
+
+**工作逻辑**:
+- 必须精确匹配 search 字段中的代码段（包括空格、缩进与换行）
+- 只有当所有指定的 chunks 在文件中**有且仅有唯一匹配**时，才会将替换内容写入文件（dry_run 除外）
+- 任意 chunk 失败则**整次事务不写盘**，并返回诊断上下文 + 建议 search 块
+- search 为空、结果无变化（noop）、文件过大均会拒绝
+
+**最佳实践（强烈推荐给 LLM）**:
+- 使用包含周围几行的较大唯一块作为 search，而不是孤立的一行。
+- 复制时务必 100% 精确，包括所有空白和换行。
+- 不确定时，先调用 read 工具获取文件精确内容片段再构造 patch。
+- 可用 dry_run=true 先预览 unified diff。`,
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Absolute or relative path to the target file",
+            },
+            chunks: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        search: {
+                            type: "string",
+                            description: "The exact block of code to search for, including leading indent and whitespace",
+                        },
+                        replace: {
+                            type: "string",
+                            description: "The code to replace it with",
+                        },
+                    },
+                    required: ["search", "replace"],
+                },
+                description: "List of replacement chunks to apply in sequence",
+            },
+            dry_run: {
+                type: "boolean",
+                description: "If true, validate and return unified diff without writing the file",
+            },
+        },
+        required: ["path", "chunks"],
+    },
+    paramSchema: {
+        path: {
+            type: "string",
+            description: "目标文件路径。相对路径以工作区为基准。",
+            minLength: 1,
+        },
+        chunks: {
+            type: "array",
+            description: "需要依次执行的精准替换块列表。",
+        },
+        dry_run: {
+            type: "boolean",
+            description: "为 true 时只预览 diff，不写盘。",
+        },
+    },
+    examples: [
+        'patch path="src/utils.ts" chunks=[{"search":"export const foo = 1;","replace":"export const foo = 2;"}]',
+        'patch path="src/utils.ts" dry_run=true chunks=[{"search":"a","replace":"b"}]',
+    ],
+    seeAlso: ["read", "write"],
+    scenes: ["coding"],
+    priority: 10,
+    readOnly: false,
+    destructive: false,
+    concurrencySafe: false,
+    effortHint: "medium",
+};
+export function computeLineStats(originalContent, newContent) {
+    const originalLines = originalContent.split(/\r?\n/);
+    const newLines = newContent.split(/\r?\n/);
+    // 简化：按行集合差估算；用于摘要（非完美 LCS 统计）
+    let oi = 0;
+    let ni = 0;
+    let added = 0;
+    let removed = 0;
+    let unchanged = 0;
+    while (oi < originalLines.length && ni < newLines.length) {
+        if (originalLines[oi] === newLines[ni]) {
+            unchanged++;
+            oi++;
+            ni++;
+            continue;
+        }
+        // 贪心：优先认为是替换
+        const lookAhead = originalLines.indexOf(newLines[ni], oi + 1);
+        const lookBack = newLines.indexOf(originalLines[oi], ni + 1);
+        if (lookAhead !== -1 && (lookBack === -1 || lookAhead - oi <= lookBack - ni)) {
+            removed += lookAhead - oi;
+            oi = lookAhead;
+        }
+        else if (lookBack !== -1) {
+            added += lookBack - ni;
+            ni = lookBack;
+        }
+        else {
+            removed++;
+            added++;
+            oi++;
+            ni++;
+        }
+    }
+    removed += originalLines.length - oi;
+    added += newLines.length - ni;
+    return { added, removed, unchanged };
+}
+export async function runPatch(args) {
+    const inputPath = String(args.path ?? "").trim();
+    if (!inputPath) {
+        return toolError("PATCH_INVALID_PATH", "path is required");
+    }
+    const chunks = args.chunks;
+    if (!Array.isArray(chunks) || chunks.length === 0) {
+        return toolError("PATCH_INVALID_CHUNKS", "chunks must be a non-empty array");
+    }
+    const dryRun = args.dry_run === true || String(args.dryRun) === "true";
+    const roots = getRuntimeRootsFromEnv();
+    const resolvedPath = resolveToolPath(inputPath, roots, "workspace");
+    if (!isPathAllowedForWrite(resolvedPath, roots)) {
+        return toolError("PATCH_OUTSIDE_ALLOWED_ROOT", `${resolvedPath} is outside write sandbox (default: workspace only; set QLING_WRITE_SANDBOX=roots|off to relax)`);
+    }
+    const sensitive = checkSensitiveWriteTarget(resolvedPath);
+    if (sensitive?.blocked) {
+        return toolError(sensitive.code, sensitive.reason, { category: "permission" });
+    }
+    let originalContent;
+    try {
+        originalContent = await readFile(resolvedPath, "utf-8");
+    }
+    catch (err) {
+        return toolError("PATCH_READ_FAILED", `failed to read file: ${getErrorMessage(err)}`);
+    }
+    const byteLength = Buffer.byteLength(originalContent, "utf-8");
+    if (byteLength > PATCH_MAX_FILE_BYTES) {
+        return toolError("PATCH_FILE_TOO_LARGE", `file is ${byteLength} bytes; max supported is ${PATCH_MAX_FILE_BYTES} bytes. Use write for large rewrites or split the file.`);
+    }
+    // Work with a copy/simulation to check all matches before writing
+    let currentContent = originalContent;
+    for (let idx = 0; idx < chunks.length; idx++) {
+        const chunk = chunks[idx];
+        const searchStr = chunk.search;
+        const replaceStr = chunk.replace;
+        if (searchStr === undefined || replaceStr === undefined) {
+            return toolError("PATCH_INVALID_CHUNK", `chunk at index ${idx} is missing search or replace field`);
+        }
+        if (searchStr === "") {
+            return toolError("PATCH_EMPTY_SEARCH", `chunk at index ${idx} has empty search; refusing ambiguous full-file match.`);
+        }
+        // Split content to search for occurrences
+        const occurrences = countOccurrences(currentContent, searchStr);
+        if (occurrences === 0) {
+            const ctx = getDiagnosticContext(currentContent, searchStr);
+            const suggestion = getSuggestedSearchBlock(currentContent, searchStr);
+            let msg = `Chunk index ${idx} search block was not found in the file. Please verify exact spelling, whitespace and indents.\n` +
+                `Tip: Use the "read" tool first to get exact text, then copy a unique block.\n` +
+                `Search block tried:\n"""\n${searchStr}\n"""\n\n` +
+                `Relevant context from file (line numbers):\n"""\n${ctx}\n"""`;
+            if (suggestion) {
+                msg += `\n\nSuggested exact block from file (copy/adapt this as your search):\n"""\n${suggestion}\n"""`;
+            }
+            return toolError("PATCH_SEARCH_NOT_FOUND", msg);
+        }
+        if (occurrences > 1) {
+            const ctx = getDiagnosticContext(currentContent, searchStr);
+            const suggestion = getSuggestedSearchBlock(currentContent, searchStr);
+            let msg = `Chunk index ${idx} search block matches ${occurrences} locations. Please provide more context lines to ensure uniqueness.\n` +
+                `Tip: Enlarge the search block with surrounding code until unique.\n` +
+                `Search block:\n"""\n${searchStr}\n"""\n\n` +
+                `Relevant context from file (line numbers):\n"""\n${ctx}\n"""`;
+            if (suggestion) {
+                msg += `\n\nSuggested unique block from file (use more context like this):\n"""\n${suggestion}\n"""`;
+            }
+            return toolError("PATCH_SEARCH_AMBIGUOUS", msg);
+        }
+        // Uniquely found, execute replacement in simulation
+        currentContent = currentContent.replace(searchStr, replaceStr);
+    }
+    if (currentContent === originalContent) {
+        return toolError("PATCH_NOOP", "all chunks applied but file content is unchanged (no-op). Refine search/replace or skip this patch.");
+    }
+    const workspaceDir = roots.workspaceDir ?? process.cwd();
+    const relFile = relative(workspaceDir, resolvedPath).replace(/\\/g, "/");
+    const stats = computeLineStats(originalContent, currentContent);
+    const diffText = generateUnifiedDiff(relFile, originalContent, currentContent);
+    const summary = `summary: chunks=${chunks.length} +${stats.added}/-${stats.removed} lines ` +
+        `(unchanged≈${stats.unchanged}) path=${relFile}`;
+    if (dryRun) {
+        return toolSuccess(`🔎 dry_run OK — would apply ${chunks.length} patch chunk(s) to ${resolvedPath}\n` +
+            `${summary}\n\n${diffText}\n\n(no file written)`);
+    }
+    // Write changes after all validations pass
+    try {
+        await writeFile(resolvedPath, currentContent, "utf-8");
+        return toolSuccess(`✅ Successfully applied ${chunks.length} patch chunk(s) to ${resolvedPath}\n` +
+            `${summary}\n\n${diffText}`);
+    }
+    catch (err) {
+        return toolError("PATCH_WRITE_FAILED", `failed to write file: ${getErrorMessage(err)}`);
+    }
+}
+function countOccurrences(text, searchStr) {
+    if (!searchStr)
+        return 0;
+    let count = 0;
+    let pos = text.indexOf(searchStr);
+    while (pos !== -1) {
+        count++;
+        pos = text.indexOf(searchStr, pos + searchStr.length);
+    }
+    return count;
+}
+/**
+ * On failure, return a line-numbered snippet around likely matching areas.
+ * Helps the LLM construct a better exact search block (Aider-like experience).
+ */
+function getDiagnosticContext(content, searchStr, contextLines = 4) {
+    const lines = content.split(/\r?\n/);
+    if (lines.length === 0)
+        return '';
+    const searchLines = searchStr.split(/\r?\n/).filter(l => l.trim().length > 0);
+    const keyPhrase = searchLines[0]?.trim().slice(0, 40) || '';
+    const candidateIdxs = [];
+    // Try direct partial match on first significant line
+    if (keyPhrase) {
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(keyPhrase) || lines[i].trim() === keyPhrase) {
+                candidateIdxs.push(i);
+            }
+        }
+    }
+    // Fallback: word based match for short unique words
+    if (candidateIdxs.length === 0) {
+        const words = keyPhrase.split(/\s+/).filter(w => w.length > 4);
+        for (let i = 0; i < lines.length; i++) {
+            if (words.some(w => lines[i].includes(w))) {
+                candidateIdxs.push(i);
+                if (candidateIdxs.length >= 3)
+                    break;
+            }
+        }
+    }
+    if (candidateIdxs.length === 0) {
+        // Last resort: head of file
+        const preview = lines.slice(0, 12).map((l, i) => `${i + 1}: ${l}`).join('\n');
+        return `File head preview:\n${preview}`;
+    }
+    const idx = candidateIdxs[0];
+    const start = Math.max(0, idx - contextLines);
+    const end = Math.min(lines.length, idx + contextLines + Math.max(1, searchLines.length));
+    let snippet = lines
+        .slice(start, end)
+        .map((l, j) => `${start + j + 1}: ${l}`)
+        .join('\n');
+    if (candidateIdxs.length > 1) {
+        snippet += `\n... (similar content also near lines: ${candidateIdxs.slice(1, 5).map(n => n + 1).join(', ')})`;
+    }
+    return snippet;
+}
+/**
+ * 当搜索失败时，尝试找到文件中与 search 最接近的实际代码块，
+ * 并返回建议的精确 search 文本（带上下文）。
+ * 这能显著帮助 LLM 构造可工作的 patch（类似 Aider 的反馈）。
+ */
+function getSuggestedSearchBlock(content, searchStr, contextLines = 2) {
+    const lines = content.split(/\r?\n/);
+    if (lines.length === 0)
+        return null;
+    const searchTrimmed = searchStr.trim();
+    if (!searchTrimmed)
+        return null;
+    let bestScore = 0;
+    let bestIdx = -1;
+    const searchLines = searchStr.split(/\r?\n/).filter(l => l.trim().length > 0);
+    const searchWords = searchTrimmed.split(/\s+/).filter(w => w.length > 2);
+    const firstSearchLine = searchStr.split(/\r?\n/)[0]?.trim() || '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let score = 0;
+        if (firstSearchLine && line.includes(firstSearchLine.slice(0, 30))) {
+            score += 20;
+        }
+        score += searchWords.filter(w => line.includes(w)).length * 3;
+        // Bonus for multi-line searches if nearby lines match
+        if (searchStr.includes('\n')) {
+            const nextSearch = searchStr.split('\n')[1]?.trim();
+            if (nextSearch && i + 1 < lines.length && lines[i + 1].includes(nextSearch.slice(0, 20))) {
+                score += 15;
+            }
+        }
+        // Deeper: consecutive line overlap score for better multi-line suggestion (Aider style)
+        let consecutive = 0;
+        for (let k = 0; k < searchLines.length && (i + k) < lines.length; k++) {
+            const sline = searchLines[k].trim().toLowerCase();
+            const aline = lines[i + k].trim().toLowerCase();
+            if (sline && (aline.includes(sline.slice(0, 20)) || sline.includes(aline.slice(0, 20)))) {
+                consecutive += 10;
+            }
+        }
+        score += consecutive;
+        if (score > bestScore) {
+            bestScore = score;
+            bestIdx = i;
+        }
+    }
+    if (bestIdx < 0 || bestScore < 4)
+        return null; // threshold to avoid bad suggestions
+    const start = Math.max(0, bestIdx - contextLines);
+    const end = Math.min(lines.length, bestIdx + contextLines + 2);
+    const block = lines.slice(start, end).join('\n');
+    return block;
+}
+export function generateUnifiedDiff(filePath, originalContent, newContent) {
+    const originalLines = originalContent.split(/\r?\n/);
+    const newLines = newContent.split(/\r?\n/);
+    const m = originalLines.length;
+    const n = newLines.length;
+    // Simple LCS DP table
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (originalLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    const diff = [];
+    let i = m, j = n;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && originalLines[i - 1] === newLines[j - 1]) {
+            diff.push({
+                type: "same",
+                line: originalLines[i - 1],
+                originalLineNum: i,
+                newLineNum: j
+            });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            diff.push({
+                type: "add",
+                line: newLines[j - 1],
+                originalLineNum: -1,
+                newLineNum: j
+            });
+            j--;
+        }
+        else {
+            diff.push({
+                type: "delete",
+                line: originalLines[i - 1],
+                originalLineNum: i,
+                newLineNum: -1
+            });
+            i--;
+        }
+    }
+    diff.reverse();
+    // Group diff items into hunks with context
+    const contextLines = 3;
+    const hunks = [];
+    let inHunk = false;
+    let hunkStart = -1;
+    let lastModifiedIdx = -1;
+    for (let idx = 0; idx < diff.length; idx++) {
+        const isMod = diff[idx].type !== "same";
+        if (isMod) {
+            if (!inHunk) {
+                inHunk = true;
+                hunkStart = Math.max(0, idx - contextLines);
+            }
+            lastModifiedIdx = idx;
+        }
+        else {
+            if (inHunk && idx - lastModifiedIdx > contextLines * 2) {
+                hunks.push({ start: hunkStart, end: lastModifiedIdx + contextLines });
+                inHunk = false;
+            }
+        }
+    }
+    if (inHunk) {
+        hunks.push({ start: hunkStart, end: Math.min(diff.length - 1, lastModifiedIdx + contextLines) });
+    }
+    // Merge overlapping hunks
+    const mergedHunks = [];
+    for (const hunk of hunks) {
+        if (mergedHunks.length === 0) {
+            mergedHunks.push(hunk);
+        }
+        else {
+            const prev = mergedHunks[mergedHunks.length - 1];
+            if (hunk.start <= prev.end) {
+                prev.end = Math.max(prev.end, hunk.end);
+            }
+            else {
+                mergedHunks.push(hunk);
+            }
+        }
+    }
+    // Format hunks into standard unified diff format
+    const result = [];
+    result.push(`--- ${filePath}`);
+    result.push(`+++ ${filePath}`);
+    for (const hunk of mergedHunks) {
+        const hunkSlice = diff.slice(hunk.start, hunk.end + 1);
+        const originalSlice = hunkSlice.filter(x => x.type !== "add");
+        const newSlice = hunkSlice.filter(x => x.type !== "delete");
+        const originalCount = originalSlice.length;
+        const newCount = newSlice.length;
+        let originalStart = 0;
+        if (originalCount > 0) {
+            originalStart = originalSlice[0].originalLineNum;
+        }
+        else {
+            originalStart = hunk.start > 0 ? diff[hunk.start - 1].originalLineNum : 0;
+        }
+        let newStart = 0;
+        if (newCount > 0) {
+            newStart = newSlice[0].newLineNum;
+        }
+        else {
+            newStart = hunk.start > 0 ? diff[hunk.start - 1].newLineNum : 0;
+        }
+        result.push(`@@ -${originalStart},${originalCount} +${newStart},${newCount} @@`);
+        for (const item of hunkSlice) {
+            if (item.type === "same") {
+                result.push(` ${item.line}`);
+            }
+            else if (item.type === "add") {
+                result.push(`+${item.line}`);
+            }
+            else {
+                result.push(`-${item.line}`);
+            }
+        }
+    }
+    return result.join("\n");
+}

package/dist/tools/planner.d.ts

@@ -0,0 +1,7 @@
+import { ToolDefinition, ToolResult } from "../types.js";
+export declare const plannerTool: ToolDefinition;
+export declare function runPlanner(args: {
+    goal: string;
+    steps?: string[];
+}): Promise<ToolResult>;
+//# sourceMappingURL=planner.d.ts.map

package/dist/tools/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/tools/planner.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,WAAW,EAAE,cA8DzB,CAAC;AAEF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,GAAG,OAAO,CAAC,UAAU,CAAC,CAiCtB"}

package/dist/tools/planner.js

@@ -0,0 +1,148 @@
+// ============================================================
+// 轻灵 - planner 工具
+// 任务规划与分解，生成结构化执行计划
+// ============================================================
+export const plannerTool = {
+    name: "planner",
+    description: "Create a structured execution plan for complex tasks. Breaks down a goal into ordered steps with status tracking. Does not execute anything — only plans.",
+    longDescription: `任务规划工具，将复杂目标分解为有序步骤。**不会执行任何操作**。
+
+**使用场景**:
+- 收到复杂任务时，先规划再执行
+- 需要拆分子任务的场景（如多文件重构）
+- 生成执行清单后逐步执行
+
+**参数说明**:
+- goal: 总体目标（一句话描述）
+- steps: 步骤数组，每个步骤包含 description 和 priority
+- 若不传 steps，则根据 goal 自动生成建议步骤
+
+**输出**:
+- 结构化计划，包含步骤编号、描述、优先级
+- 可配合 todo 工具逐步跟踪执行`,
+    parameters: {
+        type: "object",
+        properties: {
+            goal: {
+                type: "string",
+                description: "Overall goal or task description",
+            },
+            steps: {
+                type: "array",
+                description: "Optional: array of step descriptions to organize into a plan",
+                items: {
+                    type: "string",
+                },
+            },
+        },
+        required: ["goal"],
+    },
+    paramSchema: {
+        goal: {
+            type: "string",
+            description: "总体目标描述。简洁说明要完成什么。",
+            minLength: 5,
+        },
+        steps: {
+            type: "array",
+            description: "可选：步骤描述数组。若不提供，会根据 goal 自动生成建议步骤。",
+            items: {
+                type: "string",
+                description: "单个步骤描述",
+            },
+        },
+    },
+    examples: [
+        'planner goal="重构认证模块为 JWT"',
+        'planner goal="部署应用到生产环境" steps=["构建项目","运行测试","推送镜像","更新服务"]',
+    ],
+    seeAlso: ["todo", "bash"],
+    scenes: ["planning"],
+    priority: 6,
+    readOnly: true,
+    destructive: false,
+    concurrencySafe: true,
+    effortHint: "minimal",
+};
+export async function runPlanner(args) {
+    const steps = args.steps;
+    if (steps && steps.length > 0) {
+        // User provided steps — organize them
+        const lines = steps.map((s, i) => {
+            const num = String(i + 1).padStart(2, " ");
+            return `  ${num}. ⬜ ${s}`;
+        });
+        const plan = [
+            `📋 执行计划: ${args.goal}`,
+            `─────────────────────────────`,
+            ...lines,
+            `─────────────────────────────`,
+            `共 ${steps.length} 步。建议用 todo add 逐个添加后执行。`,
+        ];
+        return { tool_call_id: "", output: plan.join("\n") };
+    }
+    // Auto-generate suggested steps based on goal analysis
+    const suggestions = generateSuggestions(args.goal);
+    const plan = [
+        `📋 执行计划: ${args.goal}`,
+        `─────────────────────────────`,
+        ...suggestions.map((s, i) => {
+            const num = String(i + 1).padStart(2, " ");
+            return `  ${num}. ⬜ ${s}`;
+        }),
+        `─────────────────────────────`,
+        `建议: 用 todo add 将上述步骤添加到任务列表，然后逐步执行。`,
+        `也可直接补充步骤: planner goal="${args.goal}" steps=["步骤1","步骤2",...]`,
+    ];
+    return { tool_call_id: "", output: plan.join("\n") };
+}
+function generateSuggestions(goal) {
+    const g = goal.toLowerCase();
+    const steps = [];
+    // Detect common task patterns
+    if (/重构|refactor|重写|rewrite/i.test(g)) {
+        steps.push("分析现有代码结构（read + search）");
+        steps.push("确定重构范围和影响面");
+        steps.push("编写重构方案（DESIGN.md）");
+        steps.push("逐步实施重构");
+        steps.push("运行测试验证");
+        steps.push("清理无用代码");
+    }
+    else if (/部署|deploy|发布|release/i.test(g)) {
+        steps.push("检查构建配置和环境变量");
+        steps.push("运行完整测试套件");
+        steps.push("构建生产版本");
+        steps.push("部署到目标环境");
+        steps.push("验证部署结果");
+    }
+    else if (/修复|fix|bug|错误/i.test(g)) {
+        steps.push("定位问题（read 相关文件 + 搜索错误信息）");
+        steps.push("分析根因");
+        steps.push("实施修复");
+        steps.push("编写或更新测试");
+        steps.push("验证修复");
+    }
+    else if (/添加|add|新增|feature|功能/i.test(g)) {
+        steps.push("理解需求和技术约束");
+        steps.push("设计实现方案");
+        steps.push("编写代码");
+        steps.push("编写测试");
+        steps.push("集成验证");
+    }
+    else if (/迁移|migrate|升级|upgrade/i.test(g)) {
+        steps.push("评估迁移范围和风险");
+        steps.push("制定迁移计划");
+        steps.push("执行迁移（分批）");
+        steps.push("测试兼容性");
+        steps.push("清理旧版本依赖");
+    }
+    else {
+        // Generic fallback
+        steps.push("明确任务需求和约束");
+        steps.push("搜索和阅读相关文件");
+        steps.push("制定执行步骤");
+        steps.push("逐步实施");
+        steps.push("验证结果");
+    }
+    return steps;
+}

package/dist/tools/read.d.ts

@@ -0,0 +1,8 @@
+import { ToolDefinition, ToolResult } from "../types.js";
+export declare const readTool: ToolDefinition;
+export declare function runRead(args: {
+    path: string;
+    offset?: number;
+    limit?: number;
+}): Promise<ToolResult>;
+//# sourceMappingURL=read.d.ts.map

package/dist/tools/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/tools/read.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQzD,eAAO,MAAM,QAAQ,EAAE,cA+DtB,CAAC;AAEF,wBAAsB,OAAO,CAAC,IAAI,EAAE;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,UAAU,CAAC,CA+CtB"}