@aexol/spectral 0.7.0 → 0.7.3

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

@@ -0,0 +1,280 @@
+/**
+ * One-time migrations that run on startup.
+ */
+import chalk from "chalk";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { CONFIG_DIR_NAME, getAgentDir, getBinDir } from "./config.js";
+import { migrateKeybindingsConfig } from "./core/keybindings.js";
+const MIGRATION_GUIDE_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/CHANGELOG.md#extensions-migration";
+const EXTENSIONS_DOC_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/docs/extensions.md";
+/**
+ * Migrate legacy oauth.json and settings.json apiKeys to auth.json.
+ *
+ * @returns Array of provider names that were migrated
+ */
+export function migrateAuthToAuthJson() {
+    const agentDir = getAgentDir();
+    const authPath = join(agentDir, "auth.json");
+    const oauthPath = join(agentDir, "oauth.json");
+    const settingsPath = join(agentDir, "settings.json");
+    // Skip if auth.json already exists
+    if (existsSync(authPath))
+        return [];
+    const migrated = {};
+    const providers = [];
+    // Migrate oauth.json
+    if (existsSync(oauthPath)) {
+        try {
+            const oauth = JSON.parse(readFileSync(oauthPath, "utf-8"));
+            for (const [provider, cred] of Object.entries(oauth)) {
+                migrated[provider] = { type: "oauth", ...cred };
+                providers.push(provider);
+            }
+            renameSync(oauthPath, `${oauthPath}.migrated`);
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    // Migrate settings.json apiKeys
+    if (existsSync(settingsPath)) {
+        try {
+            const content = readFileSync(settingsPath, "utf-8");
+            const settings = JSON.parse(content);
+            if (settings.apiKeys && typeof settings.apiKeys === "object") {
+                for (const [provider, key] of Object.entries(settings.apiKeys)) {
+                    if (!migrated[provider] && typeof key === "string") {
+                        migrated[provider] = { type: "api_key", key };
+                        providers.push(provider);
+                    }
+                }
+                delete settings.apiKeys;
+                writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            }
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    if (Object.keys(migrated).length > 0) {
+        mkdirSync(dirname(authPath), { recursive: true });
+        writeFileSync(authPath, JSON.stringify(migrated, null, 2), { mode: 0o600 });
+    }
+    return providers;
+}
+/**
+ * Migrate sessions from ~/.pi/agent/*.jsonl to proper session directories.
+ *
+ * Bug in v0.30.0: Sessions were saved to ~/.pi/agent/ instead of
+ * ~/.pi/agent/sessions/<encoded-cwd>/. This migration moves them
+ * to the correct location based on the cwd in their session header.
+ *
+ * See: https://github.com/earendil-works/pi-mono/issues/320
+ */
+export function migrateSessionsFromAgentRoot() {
+    const agentDir = getAgentDir();
+    // Find all .jsonl files directly in agentDir (not in subdirectories)
+    let files;
+    try {
+        files = readdirSync(agentDir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => join(agentDir, f));
+    }
+    catch {
+        return;
+    }
+    if (files.length === 0)
+        return;
+    for (const file of files) {
+        try {
+            // Read first line to get session header
+            const content = readFileSync(file, "utf8");
+            const firstLine = content.split("\n")[0];
+            if (!firstLine?.trim())
+                continue;
+            const header = JSON.parse(firstLine);
+            if (header.type !== "session" || !header.cwd)
+                continue;
+            const cwd = header.cwd;
+            // Compute the correct session directory (same encoding as session-manager.ts)
+            const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+            const correctDir = join(agentDir, "sessions", safePath);
+            // Create directory if needed
+            if (!existsSync(correctDir)) {
+                mkdirSync(correctDir, { recursive: true });
+            }
+            // Move the file
+            const fileName = file.split("/").pop() || file.split("\\").pop();
+            const newPath = join(correctDir, fileName);
+            if (existsSync(newPath))
+                continue; // Skip if target exists
+            renameSync(file, newPath);
+        }
+        catch {
+            // Skip files that can't be migrated
+        }
+    }
+}
+/**
+ * Migrate commands/ to prompts/ if needed.
+ * Works for both regular directories and symlinks.
+ */
+function migrateCommandsToPrompts(baseDir, label) {
+    const commandsDir = join(baseDir, "commands");
+    const promptsDir = join(baseDir, "prompts");
+    if (existsSync(commandsDir) && !existsSync(promptsDir)) {
+        try {
+            renameSync(commandsDir, promptsDir);
+            console.log(chalk.green(`Migrated ${label} commands/ → prompts/`));
+            return true;
+        }
+        catch (err) {
+            console.log(chalk.yellow(`Warning: Could not migrate ${label} commands/ to prompts/: ${err instanceof Error ? err.message : err}`));
+        }
+    }
+    return false;
+}
+function migrateKeybindingsConfigFile() {
+    const configPath = join(getAgentDir(), "keybindings.json");
+    if (!existsSync(configPath))
+        return;
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return;
+        }
+        const { config, migrated } = migrateKeybindingsConfig(parsed);
+        if (!migrated)
+            return;
+        writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    }
+    catch {
+        // Ignore malformed files during migration
+    }
+}
+/**
+ * Move fd/rg binaries from tools/ to bin/ if they exist.
+ */
+function migrateToolsToBin() {
+    const agentDir = getAgentDir();
+    const toolsDir = join(agentDir, "tools");
+    const binDir = getBinDir();
+    if (!existsSync(toolsDir))
+        return;
+    const binaries = ["fd", "rg", "fd.exe", "rg.exe"];
+    let movedAny = false;
+    for (const bin of binaries) {
+        const oldPath = join(toolsDir, bin);
+        const newPath = join(binDir, bin);
+        if (existsSync(oldPath)) {
+            if (!existsSync(binDir)) {
+                mkdirSync(binDir, { recursive: true });
+            }
+            if (!existsSync(newPath)) {
+                try {
+                    renameSync(oldPath, newPath);
+                    movedAny = true;
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            else {
+                // Target exists, just delete the old one
+                try {
+                    rmSync?.(oldPath, { force: true });
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    if (movedAny) {
+        console.log(chalk.green(`Migrated managed binaries tools/ → bin/`));
+    }
+}
+/**
+ * Check for deprecated hooks/ and tools/ directories.
+ * Note: tools/ may contain fd/rg binaries extracted by pi, so only warn if it has other files.
+ */
+function checkDeprecatedExtensionDirs(baseDir, label) {
+    const hooksDir = join(baseDir, "hooks");
+    const toolsDir = join(baseDir, "tools");
+    const warnings = [];
+    if (existsSync(hooksDir)) {
+        warnings.push(`${label} hooks/ directory found. Hooks have been renamed to extensions.`);
+    }
+    if (existsSync(toolsDir)) {
+        // Check if tools/ contains anything other than fd/rg (which are auto-extracted binaries)
+        try {
+            const entries = readdirSync(toolsDir);
+            const customTools = entries.filter((e) => {
+                const lower = e.toLowerCase();
+                return (lower !== "fd" && lower !== "rg" && lower !== "fd.exe" && lower !== "rg.exe" && !e.startsWith(".") // Ignore .DS_Store and other hidden files
+                );
+            });
+            if (customTools.length > 0) {
+                warnings.push(`${label} tools/ directory contains custom tools. Custom tools have been merged into extensions.`);
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    return warnings;
+}
+/**
+ * Run extension system migrations (commands→prompts) and collect warnings about deprecated directories.
+ */
+function migrateExtensionSystem(cwd) {
+    const agentDir = getAgentDir();
+    const projectDir = join(cwd, CONFIG_DIR_NAME);
+    // Migrate commands/ to prompts/
+    migrateCommandsToPrompts(agentDir, "Global");
+    migrateCommandsToPrompts(projectDir, "Project");
+    // Check for deprecated directories
+    const warnings = [
+        ...checkDeprecatedExtensionDirs(agentDir, "Global"),
+        ...checkDeprecatedExtensionDirs(projectDir, "Project"),
+    ];
+    return warnings;
+}
+/**
+ * Print deprecation warnings and wait for keypress.
+ */
+export async function showDeprecationWarnings(warnings) {
+    if (warnings.length === 0)
+        return;
+    for (const warning of warnings) {
+        console.log(chalk.yellow(`Warning: ${warning}`));
+    }
+    console.log(chalk.yellow(`\nMove your extensions to the extensions/ directory.`));
+    console.log(chalk.yellow(`Migration guide: ${MIGRATION_GUIDE_URL}`));
+    console.log(chalk.yellow(`Documentation: ${EXTENSIONS_DOC_URL}`));
+    console.log(chalk.dim(`\nPress any key to continue...`));
+    await new Promise((resolve) => {
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        process.stdin.once("data", () => {
+            process.stdin.setRawMode?.(false);
+            process.stdin.pause();
+            resolve();
+        });
+    });
+    console.log();
+}
+/**
+ * Run all migrations. Called once on startup.
+ *
+ * @returns Object with migration results and deprecation warnings
+ */
+export function runMigrations(cwd) {
+    const migratedAuthProviders = migrateAuthToAuthJson();
+    migrateSessionsFromAgentRoot();
+    migrateToolsToBin();
+    migrateKeybindingsConfigFile();
+    const deprecationWarnings = migrateExtensionSystem(cwd);
+    return { migratedAuthProviders, deprecationWarnings };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Run modes for the coding agent.
+ */
+export { InteractiveMode } from "./interactive/interactive-mode.js";
+export { runPrintMode } from "./print-mode.js";
+export { RpcClient } from "./rpc/rpc-client.js";
+export { runRpcMode } from "./rpc/rpc-mode.js";

package/dist/pi/coding-agent/modes/interactive/components/diff.js

@@ -0,0 +1,132 @@
+import * as Diff from "diff";
+import { theme } from "../theme/theme.js";
+/**
+ * Parse diff line to extract prefix, line number, and content.
+ * Format: "+123 content" or "-123 content" or " 123 content" or "     ..."
+ */
+function parseDiffLine(line) {
+    const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+    if (!match)
+        return null;
+    return { prefix: match[1], lineNum: match[2], content: match[3] };
+}
+/**
+ * Replace tabs with spaces for consistent rendering.
+ */
+function replaceTabs(text) {
+    return text.replace(/\t/g, "   ");
+}
+/**
+ * Compute word-level diff and render with inverse on changed parts.
+ * Uses diffWords which groups whitespace with adjacent words for cleaner highlighting.
+ * Strips leading whitespace from inverse to avoid highlighting indentation.
+ */
+function renderIntraLineDiff(oldContent, newContent) {
+    const wordDiff = Diff.diffWords(oldContent, newContent);
+    let removedLine = "";
+    let addedLine = "";
+    let isFirstRemoved = true;
+    let isFirstAdded = true;
+    for (const part of wordDiff) {
+        if (part.removed) {
+            let value = part.value;
+            // Strip leading whitespace from the first removed part
+            if (isFirstRemoved) {
+                const leadingWs = value.match(/^(\s*)/)?.[1] || "";
+                value = value.slice(leadingWs.length);
+                removedLine += leadingWs;
+                isFirstRemoved = false;
+            }
+            if (value) {
+                removedLine += theme.inverse(value);
+            }
+        }
+        else if (part.added) {
+            let value = part.value;
+            // Strip leading whitespace from the first added part
+            if (isFirstAdded) {
+                const leadingWs = value.match(/^(\s*)/)?.[1] || "";
+                value = value.slice(leadingWs.length);
+                addedLine += leadingWs;
+                isFirstAdded = false;
+            }
+            if (value) {
+                addedLine += theme.inverse(value);
+            }
+        }
+        else {
+            removedLine += part.value;
+            addedLine += part.value;
+        }
+    }
+    return { removedLine, addedLine };
+}
+/**
+ * Render a diff string with colored lines and intra-line change highlighting.
+ * - Context lines: dim/gray
+ * - Removed lines: red, with inverse on changed tokens
+ * - Added lines: green, with inverse on changed tokens
+ */
+export function renderDiff(diffText, _options = {}) {
+    const lines = diffText.split("\n");
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const parsed = parseDiffLine(line);
+        if (!parsed) {
+            result.push(theme.fg("toolDiffContext", line));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === "-") {
+            // Collect consecutive removed lines
+            const removedLines = [];
+            while (i < lines.length) {
+                const p = parseDiffLine(lines[i]);
+                if (!p || p.prefix !== "-")
+                    break;
+                removedLines.push({ lineNum: p.lineNum, content: p.content });
+                i++;
+            }
+            // Collect consecutive added lines
+            const addedLines = [];
+            while (i < lines.length) {
+                const p = parseDiffLine(lines[i]);
+                if (!p || p.prefix !== "+")
+                    break;
+                addedLines.push({ lineNum: p.lineNum, content: p.content });
+                i++;
+            }
+            // Only do intra-line diffing when there's exactly one removed and one added line
+            // (indicating a single line modification). Otherwise, show lines as-is.
+            if (removedLines.length === 1 && addedLines.length === 1) {
+                const removed = removedLines[0];
+                const added = addedLines[0];
+                const { removedLine, addedLine } = renderIntraLineDiff(replaceTabs(removed.content), replaceTabs(added.content));
+                result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${removedLine}`));
+                result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${addedLine}`));
+            }
+            else {
+                // Show all removed lines first, then all added lines
+                for (const removed of removedLines) {
+                    result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${replaceTabs(removed.content)}`));
+                }
+                for (const added of addedLines) {
+                    result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${replaceTabs(added.content)}`));
+                }
+            }
+        }
+        else if (parsed.prefix === "+") {
+            // Standalone added line
+            result.push(theme.fg("toolDiffAdded", `+${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+            i++;
+        }
+        else {
+            // Context line
+            result.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+            i++;
+        }
+    }
+    return result.join("\n");
+}

package/dist/pi/coding-agent/modes/interactive/components/keybinding-hints.js

@@ -0,0 +1,35 @@
+/**
+ * Utilities for formatting keybinding hints in the UI.
+ */
+import { getKeybindings } from "../../../../tui/index.js";
+import { theme } from "../theme/theme.js";
+function formatKeyPart(part, options) {
+    const displayPart = process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part;
+    return options.capitalize ? displayPart.charAt(0).toUpperCase() + displayPart.slice(1) : displayPart;
+}
+export function formatKeyText(key, options = {}) {
+    return key
+        .split("/")
+        .map((k) => k
+        .split("+")
+        .map((part) => formatKeyPart(part, options))
+        .join("+"))
+        .join("/");
+}
+function formatKeys(keys, options = {}) {
+    if (keys.length === 0)
+        return "";
+    return formatKeyText(keys.join("/"), options);
+}
+export function keyText(keybinding) {
+    return formatKeys(getKeybindings().getKeys(keybinding));
+}
+export function keyDisplayText(keybinding) {
+    return formatKeys(getKeybindings().getKeys(keybinding), { capitalize: true });
+}
+export function keyHint(keybinding, description) {
+    return theme.fg("dim", keyText(keybinding)) + theme.fg("muted", ` ${description}`);
+}
+export function rawKeyHint(key, description) {
+    return theme.fg("dim", formatKeyText(key)) + theme.fg("muted", ` ${description}`);
+}

package/dist/pi/coding-agent/modes/interactive/components/visual-truncate.js

@@ -0,0 +1,32 @@
+/**
+ * Shared utility for truncating text to visual lines (accounting for line wrapping).
+ * Used by both tool-execution.ts and bash-execution.ts for consistent behavior.
+ */
+import { Text } from "../../../../tui/index.js";
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export function truncateToVisualLines(text, maxVisualLines, width, paddingX = 0) {
+    if (!text) {
+        return { visualLines: [], skippedCount: 0 };
+    }
+    // Create a temporary Text component to render and get visual lines
+    const tempText = new Text(text, paddingX, 0);
+    const allVisualLines = tempText.render(width);
+    if (allVisualLines.length <= maxVisualLines) {
+        return { visualLines: allVisualLines, skippedCount: 0 };
+    }
+    // Take the last N visual lines
+    const truncatedLines = allVisualLines.slice(-maxVisualLines);
+    const skippedCount = allVisualLines.length - maxVisualLines;
+    return { visualLines: truncatedLines, skippedCount };
+}

package/dist/pi/coding-agent/modes/interactive/interactive-mode.js

@@ -0,0 +1,3 @@
+// Interactive mode removed (not used in SDK mode by spectral)
+// Replaced with no-op exports to satisfy imports during build.
+export const InteractiveMode = undefined;