@aexol/spectral 0.9.159 → 0.9.160

package/dist/sdk/coding-agent/core/tools/ls.js

@@ -1,156 +0,0 @@
-import { existsSync, readdirSync, statSync } from "fs";
-import nodePath from "path";
-import { Type } from "typebox";
-import { resolveToCwd } from "./path-utils.js";
-import { getTextOutput, shortenPath, str } from "./render-utils.js";
-import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
-const lsSchema = Type.Object({
-    path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
-});
-const DEFAULT_LIMIT = 500;
-const defaultLsOperations = {
-    exists: existsSync,
-    stat: statSync,
-    readdir: readdirSync,
-};
-function formatLsCall(args, _theme) {
-    const rawPath = str(args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
-    const limit = args?.limit;
-    const invalidArg = "[invalid]";
-    let text = `ls ${path === null ? invalidArg : path}`;
-    if (limit !== undefined) {
-        text += ` (limit ${limit})`;
-    }
-    return text;
-}
-function formatLsResult(result, options, _theme, showImages) {
-    const output = getTextOutput(result, showImages).trim();
-    let text = "";
-    if (output) {
-        const lines = output.split("\n");
-        const maxLines = options.expanded ? lines.length : 20;
-        const displayLines = lines.slice(0, maxLines);
-        const remaining = lines.length - maxLines;
-        text += `\n${displayLines.join("\n")}`;
-        if (remaining > 0) {
-            text += `\n... (${remaining} more lines)`;
-        }
-    }
-    const entryLimit = result.details?.entryLimitReached;
-    const truncation = result.details?.truncation;
-    if (entryLimit || truncation?.truncated) {
-        const warnings = [];
-        if (entryLimit)
-            warnings.push(`${entryLimit} entries limit`);
-        if (truncation?.truncated)
-            warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-        text += `\n[Truncated: ${warnings.join(", ")}]`;
-    }
-    return text;
-}
-export function createLsToolDefinition(cwd, options) {
-    const ops = options?.operations ?? defaultLsOperations;
-    return {
-        name: "ls",
-        label: "ls",
-        description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
-        promptSnippet: "List directory contents",
-        parameters: lsSchema,
-        async execute(_toolCallId, { path, limit }, signal, _onUpdate, _ctx) {
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                const onAbort = () => reject(new Error("Operation aborted"));
-                signal?.addEventListener("abort", onAbort, { once: true });
-                (async () => {
-                    try {
-                        const dirPath = resolveToCwd(path || ".", cwd);
-                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
-                        // Check if path exists.
-                        if (!(await ops.exists(dirPath))) {
-                            reject(new Error(`Path not found: ${dirPath}`));
-                            return;
-                        }
-                        // Check if path is a directory.
-                        const stat = await ops.stat(dirPath);
-                        if (!stat.isDirectory()) {
-                            reject(new Error(`Not a directory: ${dirPath}`));
-                            return;
-                        }
-                        // Read directory entries.
-                        let entries;
-                        try {
-                            entries = await ops.readdir(dirPath);
-                        }
-                        catch (e) {
-                            reject(new Error(`Cannot read directory: ${e.message}`));
-                            return;
-                        }
-                        // Sort alphabetically, case-insensitive.
-                        entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-                        // Format entries with directory indicators.
-                        const results = [];
-                        let entryLimitReached = false;
-                        for (const entry of entries) {
-                            if (results.length >= effectiveLimit) {
-                                entryLimitReached = true;
-                                break;
-                            }
-                            const fullPath = nodePath.join(dirPath, entry);
-                            let suffix = "";
-                            try {
-                                const entryStat = await ops.stat(fullPath);
-                                if (entryStat.isDirectory())
-                                    suffix = "/";
-                            }
-                            catch {
-                                // Skip entries we cannot stat.
-                                continue;
-                            }
-                            results.push(entry + suffix);
-                        }
-                        signal?.removeEventListener("abort", onAbort);
-                        if (results.length === 0) {
-                            resolve({ content: [{ type: "text", text: "(empty directory)" }], details: undefined });
-                            return;
-                        }
-                        const rawOutput = results.join("\n");
-                        // Apply byte truncation. There is no separate line limit because entry count is already capped.
-                        const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-                        let output = truncation.content;
-                        const details = {};
-                        // Build actionable notices for truncation and entry limits.
-                        const notices = [];
-                        if (entryLimitReached) {
-                            notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
-                            details.entryLimitReached = effectiveLimit;
-                        }
-                        if (truncation.truncated) {
-                            notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-                            details.truncation = truncation;
-                        }
-                        if (notices.length > 0) {
-                            output += `\n\n[${notices.join(". ")}]`;
-                        }
-                        resolve({
-                            content: [{ type: "text", text: output }],
-                            details: Object.keys(details).length > 0 ? details : undefined,
-                        });
-                    }
-                    catch (e) {
-                        signal?.removeEventListener("abort", onAbort);
-                        reject(e);
-                    }
-                })();
-            });
-        },
-    };
-}
-export function createLsTool(cwd, options) {
-    return wrapToolDefinition(createLsToolDefinition(cwd, options));
-}

package/dist/sdk/coding-agent/core/tools/write.d.ts

@@ -1,23 +0,0 @@
-import type { AgentTool } from "../../../agent-core/index.js";
-import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.js";
-declare const writeSchema: Type.TObject<{
-    path: Type.TString;
-    content: Type.TString;
-}>;
-export type WriteToolInput = Static<typeof writeSchema>;
-export interface WriteOperations {
-    /**
-     * Optional atomic write override (temp file + rename). When omitted,
-     * the default {@link atomicWriteFile} helper is used.
-     */
-    atomicWrite?: (absolutePath: string, content: string) => Promise<void>;
-    mkdir: (dir: string) => Promise<void>;
-}
-export interface WriteToolOptions {
-    operations?: WriteOperations;
-}
-export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition<typeof writeSchema, undefined>;
-export declare function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema>;
-export {};
-//# sourceMappingURL=write.d.ts.map

package/dist/sdk/coding-agent/core/tools/write.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAe7D,QAAA,MAAM,WAAW;;;EAKf,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AACxD,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAID,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,eAAe,CAAC;CAC9B;AA+DD,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CA+E/C;AACD,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,gBAAgB,GACzB,SAAS,CAAC,OAAO,WAAW,CAAC,CAE/B"}

package/dist/sdk/coding-agent/core/tools/write.js

@@ -1,134 +0,0 @@
-import { mkdir as fsMkdir } from "fs/promises";
-import { dirname } from "path";
-import { Type } from "typebox";
-import { getLanguageFromPath, highlightCode } from "../theme.js";
-import { atomicWriteFile, defaultAtomicWriteOperations, } from "./atomic-write.js";
-import { withFileMutationQueue } from "./file-mutation-queue.js";
-import { resolveToCwd } from "./path-utils.js";
-import { normalizeDisplayText, replaceTabs, shortenPath, str, } from "./render-utils.js";
-import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-const writeSchema = Type.Object({
-    path: Type.String({
-        description: "Path to the file to write (relative or absolute)",
-    }),
-    content: Type.String({ description: "Content to write to the file" }),
-});
-const defaultWriteOperations = {
-    mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
-};
-function trimTrailingEmptyLines(lines) {
-    let end = lines.length;
-    while (end > 0 && lines[end - 1] === "") {
-        end--;
-    }
-    return lines.slice(0, end);
-}
-function formatWriteCall(args, options, _theme) {
-    const rawPath = str(args?.file_path ?? args?.path);
-    const fileContent = str(args?.content);
-    const path = rawPath !== null ? shortenPath(rawPath) : null;
-    const pathDisplay = path === null ? "[invalid]" : path || "...";
-    let text = `write ${pathDisplay}`;
-    if (fileContent === null) {
-        text += `\n\n[invalid content arg - expected string]`;
-    }
-    else if (fileContent) {
-        const lines = trimTrailingEmptyLines(normalizeDisplayText(fileContent).split("\n"));
-        const totalLines = lines.length;
-        const maxLines = options.expanded ? totalLines : 10;
-        const preview = lines.slice(0, maxLines);
-        const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
-        const displayLines = lang
-            ? highlightCode(replaceTabs(preview.join("\n")), lang)
-            : preview;
-        const remaining = totalLines - maxLines;
-        text += `\n\n${displayLines.join("\n")}`;
-        if (remaining > 0) {
-            text += `\n... (${remaining} more lines, ${totalLines} total)`;
-        }
-    }
-    return text;
-}
-function formatWriteResult(result, _theme) {
-    if (!result.isError) {
-        return undefined;
-    }
-    const output = result.content
-        .filter((c) => c.type === "text")
-        .map((c) => c.text || "")
-        .join("\n");
-    if (!output) {
-        return undefined;
-    }
-    return `\n${output}`;
-}
-export function createWriteToolDefinition(cwd, options) {
-    const ops = options?.operations ?? defaultWriteOperations;
-    const atomicOps = defaultAtomicWriteOperations;
-    return {
-        name: "write",
-        label: "write",
-        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
-        promptSnippet: "Create or overwrite files",
-        promptGuidelines: ["Use write only for new files or complete rewrites."],
-        parameters: writeSchema,
-        async execute(_toolCallId, { path, content }, signal, _onUpdate, _ctx) {
-            const absolutePath = resolveToCwd(path, cwd);
-            const dir = dirname(absolutePath);
-            return withFileMutationQueue(absolutePath, () => new Promise((resolve, reject) => {
-                // Abort BEFORE the write begins -> reject immediately.
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                let writeStarted = false;
-                const onAbort = () => {
-                    aborted = true;
-                    // W2: only reject when aborted BEFORE the write begins. An abort
-                    // that fires during/after the write must not swallow the
-                    // successful resolve once the write completes.
-                    if (!writeStarted) {
-                        reject(new Error("Operation aborted"));
-                    }
-                };
-                signal?.addEventListener("abort", onAbort, { once: true });
-                (async () => {
-                    try {
-                        await ops.mkdir(dir);
-                        // Reject if aborted before the write begins.
-                        if (aborted)
-                            return;
-                        writeStarted = true;
-                        // W1 + W5: atomic write (temp + rename). On failure the
-                        // temp is cleaned up and the target is left untouched.
-                        const writeFn = ops.atomicWrite ??
-                            ((p, c) => atomicWriteFile(p, c, "utf-8", atomicOps));
-                        await writeFn(absolutePath, content);
-                        // W2: once the write has completed successfully, resolve
-                        // with the success content even if the abort signal
-                        // fired mid-write. Do NOT swallow the resolve.
-                        signal?.removeEventListener("abort", onAbort);
-                        resolve({
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Successfully wrote ${Buffer.byteLength(content, "utf-8")} bytes to ${path}`,
-                                },
-                            ],
-                            details: undefined,
-                        });
-                    }
-                    catch (error) {
-                        signal?.removeEventListener("abort", onAbort);
-                        if (!aborted)
-                            reject(error);
-                    }
-                })();
-            }));
-        },
-    };
-}
-export function createWriteTool(cwd, options) {
-    return wrapToolDefinition(createWriteToolDefinition(cwd, options));
-}