aws-runtime-bridge 1.7.49 → 1.8.0

package/package/acode/dist/built-in-file-tools.js

@@ -0,0 +1,569 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function toDisplayPath(targetPath) {
+    return targetPath.replace(/\\/g, "/");
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function countOccurrences(content, search) {
+    if (!search) {
+        return 0;
+    }
+    let count = 0;
+    let index = content.indexOf(search);
+    while (index >= 0) {
+        count += 1;
+        index = content.indexOf(search, index + search.length);
+    }
+    return count;
+}
+function readStringArg(args, names, label) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === "string") {
+            return value;
+        }
+    }
+    throw new Error(`${label} is required`);
+}
+function readOptionalStringArg(args, names) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === "string" && value.trim()) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readOptionalPositiveIntegerArg(args, names, fallback) {
+    for (const name of names) {
+        const value = args[name];
+        const numeric = typeof value === "number"
+            ? value
+            : typeof value === "string"
+                ? Number(value)
+                : NaN;
+        if (Number.isFinite(numeric) && numeric > 0) {
+            return Math.floor(numeric);
+        }
+    }
+    return fallback;
+}
+function ensureInsideWorkspace(workspaceRoot, targetPath) {
+    const resolvedTargetPath = path.resolve(targetPath);
+    const relativePath = path.relative(workspaceRoot, resolvedTargetPath);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        throw new Error(`Target path is outside workspace: ${resolvedTargetPath}`);
+    }
+    return resolvedTargetPath;
+}
+async function resolveWorkspaceDirectory(workingDirectory, rawCwd) {
+    const requestedRoot = path.resolve(String(workingDirectory || "").trim());
+    const workspaceRoot = await fs.realpath(requestedRoot);
+    const workspaceStat = await fs.stat(workspaceRoot);
+    if (!workspaceStat.isDirectory()) {
+        throw new Error(`Workspace path is not a directory: ${requestedRoot}`);
+    }
+    if (!rawCwd?.trim()) {
+        return { workspaceRoot, cwd: workspaceRoot };
+    }
+    const requestedCwd = rawCwd.trim();
+    const candidatePath = path.isAbsolute(requestedCwd)
+        ? path.resolve(requestedCwd)
+        : path.resolve(requestedRoot, requestedCwd);
+    const requestedRelativePath = path.relative(requestedRoot, candidatePath);
+    if (requestedRelativePath.startsWith("..") ||
+        path.isAbsolute(requestedRelativePath)) {
+        throw new Error(`Command cwd is outside workspace: ${candidatePath}`);
+    }
+    const realCwd = ensureInsideWorkspace(workspaceRoot, await fs.realpath(candidatePath));
+    const cwdStat = await fs.stat(realCwd);
+    if (!cwdStat.isDirectory()) {
+        throw new Error(`Command cwd is not a directory: ${realCwd}`);
+    }
+    return { workspaceRoot, cwd: realCwd };
+}
+async function ensureWritableTarget(workspaceRoot, targetPath) {
+    const realParentPath = await fs.realpath(path.dirname(targetPath));
+    ensureInsideWorkspace(workspaceRoot, realParentPath);
+    try {
+        const targetLinkStat = await fs.lstat(targetPath);
+        if (targetLinkStat.isSymbolicLink()) {
+            throw new Error(`Refusing to write through symbolic link: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        const errorCode = typeof error === "object" && error !== null
+            ? Reflect.get(error, "code")
+            : undefined;
+        if (errorCode !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+/**
+ * 解析内置文件工具目标路径。
+ * 主流程：同时校验请求路径与 realpath 工作区边界，防止绝对路径、`..` 与符号链接目录穿透。
+ */
+async function resolveWorkspaceTarget(workingDirectory, rawFilePath) {
+    const requestedRoot = path.resolve(String(workingDirectory || "").trim());
+    const workspaceRoot = await fs.realpath(requestedRoot);
+    const workspaceStat = await fs.stat(workspaceRoot);
+    if (!workspaceStat.isDirectory()) {
+        throw new Error(`Workspace path is not a directory: ${requestedRoot}`);
+    }
+    const normalizedFilePath = rawFilePath.trim();
+    if (!normalizedFilePath) {
+        throw new Error("file_path is required");
+    }
+    const requestedPath = path.isAbsolute(normalizedFilePath)
+        ? path.resolve(normalizedFilePath)
+        : path.resolve(requestedRoot, normalizedFilePath);
+    const requestedRelativePath = path.relative(requestedRoot, requestedPath);
+    if (requestedRelativePath.startsWith("..") ||
+        path.isAbsolute(requestedRelativePath)) {
+        throw new Error(`Target path is outside workspace: ${requestedPath}`);
+    }
+    return {
+        workspaceRoot,
+        requestedPath,
+        targetPath: ensureInsideWorkspace(workspaceRoot, path.join(workspaceRoot, requestedRelativePath)),
+    };
+}
+/**
+ * 原子写入完整文件内容。
+ * 主流程：创建父目录 -> 校验 realpath 边界和符号链接 -> 写同目录临时文件 -> rename 覆盖目标。
+ */
+async function writeFileAtomically(workingDirectory, filePath, content) {
+    const target = await resolveWorkspaceTarget(workingDirectory, filePath);
+    const parentPath = path.dirname(target.targetPath);
+    const createdParentDirectory = !(await pathExists(parentPath));
+    await fs.mkdir(parentPath, { recursive: true });
+    await ensureWritableTarget(target.workspaceRoot, target.targetPath);
+    const temporaryPath = path.join(parentPath, `.${path.basename(target.targetPath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(temporaryPath, content, "utf-8");
+        await fs.rename(temporaryPath, target.targetPath);
+    }
+    catch (error) {
+        await fs.rm(temporaryPath, { force: true });
+        throw error;
+    }
+    return {
+        workspaceRoot: target.workspaceRoot,
+        targetPath: target.targetPath,
+        bytes: Buffer.byteLength(content, "utf-8"),
+        createdParentDirectory,
+    };
+}
+async function readFileInsideWorkspace(workingDirectory, filePath) {
+    const target = await resolveWorkspaceTarget(workingDirectory, filePath);
+    const realTargetPath = ensureInsideWorkspace(target.workspaceRoot, await fs.realpath(target.targetPath));
+    const stat = await fs.stat(realTargetPath);
+    if (!stat.isFile()) {
+        throw new Error(`Path is not a file: ${realTargetPath}`);
+    }
+    return {
+        workspaceRoot: target.workspaceRoot,
+        targetPath: realTargetPath,
+        content: await fs.readFile(realTargetPath, "utf-8"),
+    };
+}
+const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+const MAX_COMMAND_TIMEOUT_MS = 10 * 60_000;
+const DEFAULT_COMMAND_INACTIVITY_TIMEOUT_MS = 60_000;
+const MAX_COMMAND_INACTIVITY_TIMEOUT_MS = 10 * 60_000;
+const MAX_COMMAND_OUTPUT_BYTES = 128 * 1024;
+const COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT = 100;
+function padDatePart(value) {
+    return String(value).padStart(2, "0");
+}
+function countOutputLines(output) {
+    if (!output) {
+        return 0;
+    }
+    const normalized = output.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const withoutTrailingLineBreak = normalized.endsWith("\n")
+        ? normalized.slice(0, -1)
+        : normalized;
+    return withoutTrailingLineBreak
+        ? withoutTrailingLineBreak.split("\n").length
+        : 1;
+}
+function buildCommandOutputSpilloverPath(workspaceRoot, now = new Date()) {
+    const year = now.getFullYear();
+    const month = padDatePart(now.getMonth() + 1);
+    const day = padDatePart(now.getDate());
+    const hour = padDatePart(now.getHours());
+    const minute = padDatePart(now.getMinutes());
+    const timestamp = `${year}${month}${day}-${hour}${minute}${padDatePart(now.getSeconds())}-${String(now.getMilliseconds()).padStart(3, "0")}-${process.pid}-${randomUUID().slice(0, 8)}`;
+    return path.join(workspaceRoot, ".agentswork", "acode", "cmd-dist", `${year}-${month}-${day}`, hour, minute, `${timestamp}-cmd.out`);
+}
+async function writeCommandOutputSpilloverFile(workspaceRoot, content) {
+    const targetPath = buildCommandOutputSpilloverPath(workspaceRoot);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, content, "utf-8");
+    return targetPath;
+}
+function buildCommandOutputSpilloverContent(input) {
+    return [
+        `Command: ${input.commandText}`,
+        `CWD: ${input.cwd}`,
+        `Started: ${input.startedAt.toISOString()}`,
+        `Ended: ${input.endedAt.toISOString()}`,
+        `Exit code: ${input.exitCode ?? "null"}`,
+        `Signal: ${input.signal ?? "null"}`,
+        `Timed out: ${input.timedOut}`,
+        `Timed out by inactivity: ${input.inactivityTimedOut}`,
+        "",
+        "--- stdout ---",
+        input.stdout,
+        "",
+        "--- stderr ---",
+        input.stderr,
+    ].join("\n");
+}
+function formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount) {
+    return [
+        `[ACode] 命令输出超过 ${COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT} 行（共 ${outputLineCount} 行），完整输出已写入: ${toDisplayPath(outputFilePath)}`,
+        "[ACode] Agent 可自行读取该文件，或在该文件中搜索需要的内容。",
+        "",
+    ].join("\n");
+}
+function truncateOutput(value) {
+    const bytes = Buffer.byteLength(value, "utf-8");
+    if (bytes <= MAX_COMMAND_OUTPUT_BYTES) {
+        return { text: value, truncated: false };
+    }
+    const buffer = Buffer.from(value, "utf-8");
+    return {
+        text: buffer.subarray(0, MAX_COMMAND_OUTPUT_BYTES).toString("utf-8") +
+            `\n...[truncated after ${MAX_COMMAND_OUTPUT_BYTES} bytes]`,
+        truncated: true,
+    };
+}
+function shellExecutable() {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            argsPrefix: ["/d", "/s", "/c"],
+        };
+    }
+    return { command: process.env.SHELL || "/bin/sh", argsPrefix: ["-lc"] };
+}
+function runShellCommand(commandText, workspaceRoot, cwd, timeoutMs, inactivityTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const shell = shellExecutable();
+        const startedAt = new Date();
+        const child = spawn(shell.command, [...shell.argsPrefix, commandText], {
+            cwd,
+            env: process.env,
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let inactivityTimedOut = false;
+        let killEscalationTimer;
+        let inactivityTimer;
+        const escalateKill = () => {
+            killEscalationTimer = setTimeout(() => {
+                if (!child.killed) {
+                    child.kill("SIGKILL");
+                }
+            }, 1000);
+            killEscalationTimer.unref?.();
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            escalateKill();
+        }, timeoutMs);
+        timer.unref?.();
+        const resetInactivityTimer = () => {
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            inactivityTimer = setTimeout(() => {
+                inactivityTimedOut = true;
+                timedOut = true;
+                child.kill("SIGTERM");
+                escalateKill();
+            }, inactivityTimeoutMs);
+            inactivityTimer.unref?.();
+        };
+        resetInactivityTimer();
+        child.stdout?.setEncoding("utf-8");
+        child.stderr?.setEncoding("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+            resetInactivityTimer();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+            resetInactivityTimer();
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            if (killEscalationTimer) {
+                clearTimeout(killEscalationTimer);
+            }
+            reject(error);
+        });
+        child.on("close", async (exitCode, signal) => {
+            clearTimeout(timer);
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+            }
+            if (killEscalationTimer) {
+                clearTimeout(killEscalationTimer);
+            }
+            const endedAt = new Date();
+            const outputLineCount = countOutputLines(`${stdout}${stderr}`);
+            try {
+                if (outputLineCount > COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT) {
+                    const outputFilePath = await writeCommandOutputSpilloverFile(workspaceRoot, buildCommandOutputSpilloverContent({
+                        commandText,
+                        cwd,
+                        startedAt,
+                        endedAt,
+                        exitCode,
+                        signal,
+                        timedOut,
+                        inactivityTimedOut,
+                        stdout,
+                        stderr,
+                    }));
+                    resolve({
+                        exitCode,
+                        signal,
+                        stdout: formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount),
+                        stderr: "",
+                        durationMs: endedAt.getTime() - startedAt.getTime(),
+                        timedOut,
+                        inactivityTimedOut,
+                        outputSpilled: true,
+                        outputFilePath: toDisplayPath(outputFilePath),
+                        outputLineCount,
+                    });
+                    return;
+                }
+                const truncatedStdout = truncateOutput(stdout);
+                const truncatedStderr = truncateOutput(stderr);
+                resolve({
+                    exitCode,
+                    signal,
+                    stdout: truncatedStdout.text,
+                    stderr: truncatedStderr.text,
+                    durationMs: endedAt.getTime() - startedAt.getTime(),
+                    timedOut,
+                    inactivityTimedOut,
+                    outputSpilled: false,
+                    outputLineCount,
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+function writeFileTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "write_file",
+        exposedName: "write_file",
+        description: "Create or overwrite a UTF-8 text file inside the current workspace. Parent directories are created automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to write.",
+                },
+                content: {
+                    type: "string",
+                    description: "Complete UTF-8 file content.",
+                },
+            },
+            required: ["file_path", "content"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
+            const content = readStringArg(args, ["content"], "content");
+            const result = await writeFileAtomically(workingDirectory, filePath, content);
+            return {
+                ok: true,
+                tool: "write_file",
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                bytes: result.bytes,
+                createdParentDirectory: result.createdParentDirectory,
+            };
+        },
+    };
+}
+function editFileTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "edit_file",
+        exposedName: "edit_file",
+        description: "Replace exactly one occurrence of old_string with new_string in a UTF-8 workspace text file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to edit.",
+                },
+                old_string: {
+                    type: "string",
+                    description: "Existing text to replace. Must occur exactly once.",
+                },
+                new_string: { type: "string", description: "Replacement text." },
+            },
+            required: ["file_path", "old_string", "new_string"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
+            const oldString = readStringArg(args, ["old_string", "oldString"], "old_string");
+            const newString = readStringArg(args, ["new_string", "newString"], "new_string");
+            if (!oldString) {
+                throw new Error("old_string must not be empty");
+            }
+            const current = await readFileInsideWorkspace(workingDirectory, filePath);
+            const occurrences = countOccurrences(current.content, oldString);
+            if (occurrences === 0) {
+                throw new Error("old_string was not found in file");
+            }
+            if (occurrences > 1) {
+                throw new Error(`old_string occurs ${occurrences} times; provide a unique match`);
+            }
+            const updatedContent = current.content.replace(oldString, newString);
+            const result = await writeFileAtomically(workingDirectory, filePath, updatedContent);
+            return {
+                ok: true,
+                tool: "edit_file",
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                replacements: 1,
+                bytes: result.bytes,
+            };
+        },
+    };
+}
+function readFileTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "read_file",
+        exposedName: "read_file",
+        description: "Read a UTF-8 text file inside the current workspace.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Workspace-relative file path to read.",
+                },
+            },
+            required: ["file_path"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
+            const result = await readFileInsideWorkspace(workingDirectory, filePath);
+            return {
+                ok: true,
+                tool: "read_file",
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                content: result.content,
+            };
+        },
+    };
+}
+function bashTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "Bash",
+        exposedName: "Bash",
+        description: "Execute a shell command in the current workspace. Use for local diagnostics, builds, tests, and OS commands. The command runs with a bounded timeout and returns stdout, stderr, and exit code.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Shell command to execute." },
+                cwd: {
+                    type: "string",
+                    description: "Optional workspace-relative working directory. Defaults to the workspace root.",
+                },
+                timeout_ms: {
+                    type: "number",
+                    description: "Optional timeout in milliseconds. Defaults to 30000 and is capped at 600000.",
+                },
+                inactivity_timeout_ms: {
+                    type: "number",
+                    description: "Optional no-output timeout in milliseconds. Defaults to 60000 and is capped at 600000.",
+                },
+                description: {
+                    type: "string",
+                    description: "Optional short reason for running the command.",
+                },
+            },
+            required: ["command"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const command = readStringArg(args, ["command"], "command").trim();
+            if (!command) {
+                throw new Error("command must not be empty");
+            }
+            const requestedTimeoutMs = readOptionalPositiveIntegerArg(args, ["timeout_ms", "timeoutMs"], DEFAULT_COMMAND_TIMEOUT_MS);
+            const timeoutMs = Math.min(requestedTimeoutMs, MAX_COMMAND_TIMEOUT_MS);
+            const requestedInactivityTimeoutMs = readOptionalPositiveIntegerArg(args, ["inactivity_timeout_ms", "inactivityTimeoutMs"], DEFAULT_COMMAND_INACTIVITY_TIMEOUT_MS);
+            const inactivityTimeoutMs = Math.min(requestedInactivityTimeoutMs, MAX_COMMAND_INACTIVITY_TIMEOUT_MS);
+            const cwdArg = readOptionalStringArg(args, ["cwd"]);
+            const resolved = await resolveWorkspaceDirectory(workingDirectory, cwdArg);
+            const result = await runShellCommand(command, resolved.workspaceRoot, resolved.cwd, timeoutMs, inactivityTimeoutMs);
+            return {
+                ok: result.exitCode === 0 && !result.timedOut,
+                tool: "Bash",
+                command,
+                cwd: toDisplayPath(resolved.cwd),
+                exitCode: result.exitCode,
+                signal: result.signal,
+                timedOut: result.timedOut,
+                inactivityTimedOut: result.inactivityTimedOut,
+                timeoutMs,
+                inactivityTimeoutMs,
+                durationMs: result.durationMs,
+                outputSpilled: result.outputSpilled,
+                outputFilePath: result.outputFilePath,
+                outputLineCount: result.outputLineCount,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            };
+        },
+    };
+}
+export function createBuiltInFileTools(workingDirectory) {
+    return [
+        readFileTool(workingDirectory),
+        writeFileTool(workingDirectory),
+        editFileTool(workingDirectory),
+        bashTool(workingDirectory),
+    ];
+}

package/package/acode/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/package/acode/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/package/acode/dist/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { ACodeRuntime } from './runtime.js';
+function getFlagValue(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0) {
+        return args[index + 1];
+    }
+    const prefixed = args.find((arg) => arg.startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const cwd = path.resolve(getFlagValue(args, '--cwd') || process.cwd());
+    const configPath = getFlagValue(args, '--config');
+    const skillsDir = getFlagValue(args, '--skills-dir');
+    const prompt = getFlagValue(args, '--prompt') || args.filter((arg) => !arg.startsWith('--')).join(' ');
+    const runtime = new ACodeRuntime({
+        sessionId: getFlagValue(args, '--session-id') || randomUUID(),
+        workingDirectory: cwd,
+        configPath,
+        skillsDir,
+        initialPrompt: prompt,
+        model: getFlagValue(args, '--model'),
+    });
+    runtime.on('event', (event) => {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+    });
+    await runtime.start();
+    await runtime.stop();
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[acode] ${message}\n`);
+    process.exitCode = 1;
+});

package/package/acode/dist/commands/commandLoader.d.ts

@@ -0,0 +1,7 @@
+import type { ACodeCommandSpec } from '../types.js';
+/**
+ * 从命令目录加载 Markdown slash commands。
+ * 主流程：跳过不存在目录与隐藏文件 -> 解析 `.md` 文件 -> 按文件名稳定排序。
+ */
+export declare function loadAcodeCommands(commandDirs: readonly string[]): Promise<ACodeCommandSpec[]>;
+//# sourceMappingURL=commandLoader.d.ts.map

package/package/acode/dist/commands/commandLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandLoader.d.ts","sourceRoot":"","sources":["../../src/commands/commandLoader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAYpD;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgBnG"}

package/package/acode/dist/commands/commandLoader.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseAcodeCommandMarkdown } from './commandParser.js';
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 从命令目录加载 Markdown slash commands。
+ * 主流程：跳过不存在目录与隐藏文件 -> 解析 `.md` 文件 -> 按文件名稳定排序。
+ */
+export async function loadAcodeCommands(commandDirs) {
+    const commands = [];
+    for (const commandDir of commandDirs) {
+        if (!(await pathExists(commandDir))) {
+            continue;
+        }
+        const entries = await fs.readdir(commandDir, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (!entry.isFile() || entry.name.startsWith('.') || path.extname(entry.name).toLowerCase() !== '.md') {
+                continue;
+            }
+            const sourcePath = path.join(commandDir, entry.name);
+            commands.push(parseAcodeCommandMarkdown(sourcePath, await fs.readFile(sourcePath, 'utf-8')));
+        }
+    }
+    return commands;
+}

package/package/acode/dist/commands/commandParser.d.ts

@@ -0,0 +1,7 @@
+import type { ACodeCommandSpec } from '../types.js';
+/**
+ * 解析 Markdown slash command。
+ * 主流程：读取可选 YAML frontmatter -> 使用正文作为 prompt 模板 -> 缺省命令名取文件名。
+ */
+export declare function parseAcodeCommandMarkdown(sourcePath: string, rawMarkdown: string): ACodeCommandSpec;
+//# sourceMappingURL=commandParser.d.ts.map

package/package/acode/dist/commands/commandParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandParser.d.ts","sourceRoot":"","sources":["../../src/commands/commandParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA6DpD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAuBnG"}