@aexol/spectral 0.7.1 → 0.7.5

package/dist/pi/coding-agent/core/tools/truncate.js

@@ -0,0 +1,214 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Truncation is based on two independent limits - whichever is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except bash tail truncation edge case).
+ */
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
+export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+function splitLinesForCounting(content) {
+    if (content.length === 0) {
+        return [];
+    }
+    const lines = content.split("\n");
+    if (content.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
+/**
+ * Format bytes as human-readable size.
+ */
+export function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+}
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If first line exceeds byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export function truncateHead(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    // Check if no truncation needed
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Check if first line alone exceeds byte limit
+    const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+    if (firstLineBytes > maxBytes) {
+        return {
+            content: "",
+            truncated: true,
+            truncatedBy: "bytes",
+            totalLines,
+            totalBytes,
+            outputLines: 0,
+            outputBytes: 0,
+            lastLinePartial: false,
+            firstLineExceedsLimit: true,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Collect complete lines that fit
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    for (let i = 0; i < lines.length && i < maxLines; i++) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            break;
+        }
+        outputLinesArr.push(line);
+        outputBytesCount += lineBytes;
+    }
+    // If we exited due to line limit
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial: false,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for bash output where you want to see the end (errors, final results).
+ *
+ * May return partial first line if the last line of original content exceeds byte limit.
+ */
+export function truncateTail(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    // Check if no truncation needed
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Work backwards from the end
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    let lastLinePartial = false;
+    for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            // Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,
+            // take the end of the line (partial)
+            if (outputLinesArr.length === 0) {
+                const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+                outputLinesArr.unshift(truncatedLine);
+                outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+                lastLinePartial = true;
+            }
+            break;
+        }
+        outputLinesArr.unshift(line);
+        outputBytesCount += lineBytes;
+    }
+    // If we exited due to line limit
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate a string to fit within a byte limit (from the end).
+ * Handles multi-byte UTF-8 characters correctly.
+ */
+function truncateStringToBytesFromEnd(str, maxBytes) {
+    const buf = Buffer.from(str, "utf-8");
+    if (buf.length <= maxBytes) {
+        return str;
+    }
+    // Start from the end, skip maxBytes back
+    let start = buf.length - maxBytes;
+    // Find a valid UTF-8 boundary (start of a character)
+    while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
+        start++;
+    }
+    return buf.slice(start).toString("utf-8");
+}
+/**
+ * Truncate a single line to max characters, adding [truncated] suffix.
+ * Used for grep match lines.
+ */
+export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+    if (line.length <= maxChars) {
+        return { text: line, wasTruncated: false };
+    }
+    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}

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

@@ -0,0 +1,212 @@
+import { Container, Text } from "../../../tui/index.js";
+import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
+import { dirname } from "path";
+import { Type } from "typebox";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { getLanguageFromPath, highlightCode } from "../../modes/interactive/theme/theme.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { invalidArgText, 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 = {
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
+};
+class WriteCallRenderComponent extends Text {
+    cache;
+    constructor() {
+        super("", 0, 0);
+    }
+}
+const WRITE_PARTIAL_FULL_HIGHLIGHT_LINES = 50;
+function highlightSingleLine(line, lang) {
+    const highlighted = highlightCode(line, lang);
+    return highlighted[0] ?? "";
+}
+function refreshWriteHighlightPrefix(cache) {
+    const prefixCount = Math.min(WRITE_PARTIAL_FULL_HIGHLIGHT_LINES, cache.normalizedLines.length);
+    if (prefixCount === 0)
+        return;
+    const prefixSource = cache.normalizedLines.slice(0, prefixCount).join("\n");
+    const prefixHighlighted = highlightCode(prefixSource, cache.lang);
+    for (let i = 0; i < prefixCount; i++) {
+        cache.highlightedLines[i] =
+            prefixHighlighted[i] ?? highlightSingleLine(cache.normalizedLines[i] ?? "", cache.lang);
+    }
+}
+function rebuildWriteHighlightCacheFull(rawPath, fileContent) {
+    const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+    if (!lang)
+        return undefined;
+    const displayContent = normalizeDisplayText(fileContent);
+    const normalized = replaceTabs(displayContent);
+    return {
+        rawPath,
+        lang,
+        rawContent: fileContent,
+        normalizedLines: normalized.split("\n"),
+        highlightedLines: highlightCode(normalized, lang),
+    };
+}
+function updateWriteHighlightCacheIncremental(cache, rawPath, fileContent) {
+    const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+    if (!lang)
+        return undefined;
+    if (!cache)
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (cache.lang !== lang || cache.rawPath !== rawPath)
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (!fileContent.startsWith(cache.rawContent))
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (fileContent.length === cache.rawContent.length)
+        return cache;
+    const deltaRaw = fileContent.slice(cache.rawContent.length);
+    const deltaDisplay = normalizeDisplayText(deltaRaw);
+    const deltaNormalized = replaceTabs(deltaDisplay);
+    cache.rawContent = fileContent;
+    if (cache.normalizedLines.length === 0) {
+        cache.normalizedLines.push("");
+        cache.highlightedLines.push("");
+    }
+    const segments = deltaNormalized.split("\n");
+    const lastIndex = cache.normalizedLines.length - 1;
+    cache.normalizedLines[lastIndex] += segments[0];
+    cache.highlightedLines[lastIndex] = highlightSingleLine(cache.normalizedLines[lastIndex], cache.lang);
+    for (let i = 1; i < segments.length; i++) {
+        cache.normalizedLines.push(segments[i]);
+        cache.highlightedLines.push(highlightSingleLine(segments[i], cache.lang));
+    }
+    refreshWriteHighlightPrefix(cache);
+    return cache;
+}
+function trimTrailingEmptyLines(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1] === "") {
+        end--;
+    }
+    return lines.slice(0, end);
+}
+function formatWriteCall(args, options, theme, cache) {
+    const rawPath = str(args?.file_path ?? args?.path);
+    const fileContent = str(args?.content);
+    const path = rawPath !== null ? shortenPath(rawPath) : null;
+    const invalidArg = invalidArgText(theme);
+    let text = `${theme.fg("toolTitle", theme.bold("write"))} ${path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...")}`;
+    if (fileContent === null) {
+        text += `\n\n${theme.fg("error", "[invalid content arg - expected string]")}`;
+    }
+    else if (fileContent) {
+        const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+        const renderedLines = lang
+            ? (cache?.highlightedLines ?? highlightCode(replaceTabs(normalizeDisplayText(fileContent)), lang))
+            : normalizeDisplayText(fileContent).split("\n");
+        const lines = trimTrailingEmptyLines(renderedLines);
+        const totalLines = lines.length;
+        const maxLines = options.expanded ? lines.length : 10;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n\n${displayLines.map((line) => (lang ? line : theme.fg("toolOutput", replaceTabs(line)))).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")})`;
+        }
+    }
+    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${theme.fg("error", output)}`;
+}
+export function createWriteToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultWriteOperations;
+    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) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let aborted = false;
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error("Operation aborted"));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                (async () => {
+                    try {
+                        // Create parent directories if needed.
+                        await ops.mkdir(dir);
+                        if (aborted)
+                            return;
+                        // Write the file contents.
+                        await ops.writeFile(absolutePath, content);
+                        if (aborted)
+                            return;
+                        signal?.removeEventListener("abort", onAbort);
+                        resolve({
+                            content: [
+                                { type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` },
+                            ],
+                            details: undefined,
+                        });
+                    }
+                    catch (error) {
+                        signal?.removeEventListener("abort", onAbort);
+                        if (!aborted)
+                            reject(error);
+                    }
+                })();
+            }));
+        },
+        renderCall(args, theme, context) {
+            const renderArgs = args;
+            const rawPath = str(renderArgs?.file_path ?? renderArgs?.path);
+            const fileContent = str(renderArgs?.content);
+            const component = context.lastComponent ?? new WriteCallRenderComponent();
+            if (fileContent !== null) {
+                component.cache = context.argsComplete
+                    ? rebuildWriteHighlightCacheFull(rawPath, fileContent)
+                    : updateWriteHighlightCacheIncremental(component.cache, rawPath, fileContent);
+            }
+            else {
+                component.cache = undefined;
+            }
+            component.setText(formatWriteCall(renderArgs, { expanded: context.expanded, isPartial: context.isPartial }, theme, component.cache));
+            return component;
+        },
+        renderResult(result, _options, theme, context) {
+            const output = formatWriteResult({ ...result, isError: context.isError }, theme);
+            if (!output) {
+                const component = context.lastComponent ?? new Container();
+                component.clear();
+                return component;
+            }
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(output);
+            return text;
+        },
+    };
+}
+export function createWriteTool(cwd, options) {
+    return wrapToolDefinition(createWriteToolDefinition(cwd, options));
+}

package/dist/pi/coding-agent/index.js

@@ -0,0 +1,41 @@
+// Core session management
+// Config paths
+export { getAgentDir, VERSION } from "./config.js";
+export { AgentSession, parseSkillBlock, } from "./core/agent-session.js";
+// Auth and model registry
+export { AuthStorage, FileAuthStorageBackend, InMemoryAuthStorageBackend, } from "./core/auth-storage.js";
+// Compaction
+export { calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, findTurnStartIndex, generateBranchSummary, generateSummary, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.js";
+export { createEventBus } from "./core/event-bus.js";
+export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, } from "./core/extensions/index.js";
+export { convertToLlm } from "./core/messages.js";
+export { ModelRegistry } from "./core/model-registry.js";
+export { DefaultPackageManager } from "./core/package-manager.js";
+export { DefaultResourceLoader, loadProjectContextFiles } from "./core/resource-loader.js";
+// SDK for programmatic usage
+export { AgentSessionRuntime, 
+// Factory
+createAgentSession, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashTool, 
+// Tool factories (for custom cwd)
+createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, } from "./core/sdk.js";
+export { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, migrateSessionEntries, parseSessionEntries, SessionManager, } from "./core/session-manager.js";
+export { SettingsManager, } from "./core/settings-manager.js";
+// Skills
+export { formatSkillsForPrompt, loadSkills, loadSkillsFromDir, } from "./core/skills.js";
+export { createSyntheticSourceInfo } from "./core/source-info.js";
+// Tools
+export { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLocalBashOperations, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, withFileMutationQueue, } from "./core/tools/index.js";
+// Main entry point
+// main.ts removed (interactive-only, not used in SDK mode)
+// Run modes for programmatic SDK usage
+export { InteractiveMode, RpcClient, runPrintMode, runRpcMode, } from "./modes/index.js";
+// UI components for extensions
+// Interactive components removed (not used in SDK mode, TUI dependencies stripped)
+// Theme utilities for custom tools and extensions
+export { getLanguageFromPath, getMarkdownTheme, getSelectListTheme, getSettingsListTheme, highlightCode, initTheme, Theme, } from "./modes/interactive/theme/theme.js";
+// Clipboard utilities
+export { copyToClipboard } from "./utils/clipboard.js";
+export { parseFrontmatter, stripFrontmatter } from "./utils/frontmatter.js";
+export { formatDimensionNote, resizeImage } from "./utils/image-resize.js";
+// Shell utilities
+export { getShellConfig } from "./utils/shell.js";

package/dist/pi/coding-agent/main.js

@@ -0,0 +1,5 @@
+// CLI entry point removed (interactive-only, not used in SDK mode by spectral)
+// Replaced with no-op to satisfy imports during build.
+export function main(_args) {
+    throw new Error("Interactive CLI mode is not available in SDK-only build");
+}