@pellux/goodvibes-sdk 0.28.22 → 0.30.1

package/dist/_internal/platform/tools/workflow/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/workflow/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,cA0F5B,CAAC"}

package/dist/_internal/platform/tools/worklist/index.d.ts

@@ -1,6 +0,0 @@
-import type { Tool } from '../../types/tools.js';
-export declare function createWorklistTool(options?: {
-    readonly surfaceRoot?: string;
-}): Tool;
-export declare const worklistTool: Tool;
-//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/worklist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/worklist/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAiEjD,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4GpF;AAED,eAAO,MAAM,YAAY,MAAuB,CAAC"}

package/dist/_internal/platform/tools/worklist/index.js

@@ -1,146 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { resolveScopedDirectory } from '../../runtime/surface-root.js';
-import { WORKLIST_TOOL_SCHEMA } from './schema.js';
-import { toRecord } from '../../utils/record-coerce.js';
-function summarizeWorklist(record) {
-    const openCount = record.items.filter((item) => item.status === 'open').length;
-    const doneCount = record.items.filter((item) => item.status === 'done').length;
-    return {
-        id: record.id,
-        title: record.title,
-        itemCount: record.items.length,
-        openCount,
-        doneCount,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt,
-    };
-}
-function worklistsPath(storageRoot, surfaceRoot) {
-    return resolveScopedDirectory(storageRoot, surfaceRoot, 'worklists.json');
-}
-function loadWorklists(storageRoot, surfaceRoot) {
-    const path = worklistsPath(storageRoot, surfaceRoot);
-    if (!existsSync(path))
-        return [];
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
-        return parsed?.version === 1 && Array.isArray(parsed.worklists) ? [...parsed.worklists] : [];
-    }
-    catch {
-        return [];
-    }
-}
-function saveWorklists(storageRoot, worklists, surfaceRoot) {
-    const path = worklistsPath(storageRoot, surfaceRoot);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify({ version: 1, worklists }, null, 2) + '\n', 'utf-8');
-}
-export function createWorklistTool(options) {
-    const surfaceRoot = options?.surfaceRoot;
-    return {
-        definition: {
-            name: 'worklist',
-            description: 'Manage durable worklists and checklist items for execution planning and follow-up.',
-            parameters: toRecord(WORKLIST_TOOL_SCHEMA),
-            sideEffects: ['workflow', 'state'],
-            concurrency: 'serial',
-        },
-        async execute(args) {
-            if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
-                return { success: false, error: 'Invalid args: mode is required.' };
-            }
-            const input = args;
-            if (!input.storageRoot || input.storageRoot.trim().length === 0) {
-                return { success: false, error: 'worklist requires storageRoot.' };
-            }
-            const worklists = loadWorklists(input.storageRoot, surfaceRoot);
-            const view = input.view ?? 'summary';
-            if (input.mode === 'create') {
-                if (!input.worklistId || !input.title) {
-                    return { success: false, error: 'create requires worklistId and title.' };
-                }
-                if (worklists.some((entry) => entry.id === input.worklistId)) {
-                    return { success: false, error: `Worklist already exists: ${input.worklistId}` };
-                }
-                const now = Date.now();
-                const record = {
-                    id: input.worklistId,
-                    title: input.title,
-                    items: [],
-                    createdAt: now,
-                    updatedAt: now,
-                };
-                saveWorklists(input.storageRoot, [...worklists, record], surfaceRoot);
-                return { success: true, output: JSON.stringify(record) };
-            }
-            if (input.mode === 'list') {
-                return {
-                    success: true,
-                    output: JSON.stringify({
-                        view,
-                        count: worklists.length,
-                        worklists: view === 'full' ? worklists : worklists.map(summarizeWorklist),
-                    }),
-                };
-            }
-            const index = worklists.findIndex((entry) => entry.id === input.worklistId);
-            if (index < 0) {
-                return { success: false, error: `Unknown worklist: ${input.worklistId ?? '(missing)'}` };
-            }
-            const current = worklists[index];
-            if (input.mode === 'show') {
-                return {
-                    success: true,
-                    output: JSON.stringify(view === 'full' ? current : {
-                        ...summarizeWorklist(current),
-                        items: current.items.map((item) => ({
-                            id: item.id,
-                            text: item.text,
-                            status: item.status,
-                            owner: item.owner,
-                            priority: item.priority,
-                        })),
-                    }),
-                };
-            }
-            if (input.mode === 'add-item') {
-                if (!input.itemId || !input.text)
-                    return { success: false, error: 'add-item requires itemId and text.' };
-                const next = {
-                    ...current,
-                    items: [
-                        ...current.items.filter((item) => item.id !== input.itemId),
-                        { id: input.itemId, text: input.text, status: 'open', priority: input.priority ?? 'medium', ...(input.owner ? { owner: input.owner } : {}) },
-                    ],
-                    updatedAt: Date.now(),
-                };
-                worklists[index] = next;
-                saveWorklists(input.storageRoot, worklists, surfaceRoot);
-                return { success: true, output: JSON.stringify(next) };
-            }
-            if (!input.itemId)
-                return { success: false, error: `${input.mode} requires itemId.` };
-            const nextItems = current.items
-                .filter((item) => input.mode !== 'remove-item' || item.id !== input.itemId)
-                .map((item) => {
-                if (item.id !== input.itemId)
-                    return item;
-                if (input.mode === 'complete-item')
-                    return { ...item, status: 'done' };
-                if (input.mode === 'reopen-item')
-                    return { ...item, status: 'open' };
-                return item;
-            });
-            const next = {
-                ...current,
-                items: nextItems,
-                updatedAt: Date.now(),
-            };
-            worklists[index] = next;
-            saveWorklists(input.storageRoot, worklists, surfaceRoot);
-            return { success: true, output: JSON.stringify(next) };
-        },
-    };
-}
-export const worklistTool = createWorklistTool();

package/dist/_internal/platform/tools/worklist/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/worklist/schema.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,eAAe,GAAG,aAAa,GAAG,aAAa,CAAC;IAChG,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;CACtC,CAAC"}

package/dist/_internal/platform/tools/write/index.d.ts

@@ -1,17 +0,0 @@
-import type { Tool } from '../../types/tools.js';
-import { FileStateCache } from '../../state/file-cache.js';
-import { ProjectIndex } from '../../state/project-index.js';
-import { FileUndoManager } from '../../state/file-undo.js';
-import type { ConfigManager } from '../../config/manager.js';
-import type { ToolLLM } from '../../config/tool-llm.js';
-import type { SessionChangeTracker } from '../../sessions/change-tracker.js';
-export declare function createWriteTool(options?: {
-    projectRoot: string;
-    fileCache?: FileStateCache;
-    projectIndex?: ProjectIndex;
-    fileUndoManager?: FileUndoManager;
-    configManager?: Pick<ConfigManager, 'get'>;
-    toolLLM?: Pick<ToolLLM, 'chat'>;
-    changeTracker?: Pick<SessionChangeTracker, 'recordChange'>;
-}): Tool;
-//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/write/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/write/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,sBAAsB,CAAC;AAGjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAIxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AA+S7E,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAChC,aAAa,CAAC,EAAE,IAAI,CAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC;CAC5D,GAAG,IAAI,CAmPP"}

package/dist/_internal/platform/tools/write/index.js

@@ -1,480 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, copyFileSync, unlinkSync } from 'node:fs';
-import { dirname, extname, join, relative } from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { WRITE_SCHEMA } from './schema.js';
-import { runValidators, formatValidatorFailure } from '../shared/validators.js';
-import { FileStateCache } from '../../state/file-cache.js';
-import { ProjectIndex } from '../../state/project-index.js';
-import { FileUndoManager } from '../../state/file-undo.js';
-import { AutoHealer } from '../shared/auto-heal.js';
-import { isNotebookFile } from '../../utils/notebook.js';
-import { logger } from '../../utils/logger.js';
-import { summarizeError } from '../../utils/error-display.js';
-import { resolveAndValidatePath } from '../../utils/path-safety.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Decode content from either the raw string or base64 field.
- * Returns the decoded string content.
- */
-function resolveContent(fileInput) {
-    if (fileInput.content_base64 !== undefined) {
-        return Buffer.from(fileInput.content_base64, 'base64').toString('utf-8');
-    }
-    return fileInput.content ?? '';
-}
-/**
- * Build a backup destination path inside .goodvibes/.backups/.
- * e.g. src/foo.ts -> <projectRoot>/.goodvibes/.backups/src/foo.ts.1700000000000
- */
-function buildBackupPath(resolvedPath, projectRoot) {
-    const rel = relative(projectRoot, resolvedPath);
-    return join(projectRoot, '.goodvibes', '.backups', `${rel}.${Date.now()}`);
-}
-/** Module-level constant — avoids re-allocating the Set on every validation call. */
-const VALID_CELL_TYPES = new Set(['code', 'markdown', 'raw']);
-/**
- * Validate that a string contains well-formed Jupyter notebook JSON.
- * Checks required top-level fields and per-cell structure.
- * On success, returns the parsed notebook object to avoid a redundant JSON.parse at the call site.
- */
-function validateNotebookContent(content) {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch (err) {
-        return { valid: false, error: `Invalid JSON: ${summarizeError(err)}` };
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        return { valid: false, error: 'Notebook must be a JSON object' };
-    }
-    const nb = parsed;
-    if (!('nbformat' in nb) || typeof nb['nbformat'] !== 'number') {
-        return { valid: false, error: "Notebook must have a numeric 'nbformat' field" };
-    }
-    if (!('cells' in nb) || !Array.isArray(nb['cells'])) {
-        return { valid: false, error: "Notebook must have a 'cells' array" };
-    }
-    for (let i = 0; i < nb['cells'].length; i++) {
-        const cell = nb['cells'][i];
-        if (typeof cell !== 'object' || cell === null || Array.isArray(cell)) {
-            return { valid: false, error: `Cell ${i} must be an object` };
-        }
-        const c = cell;
-        if (!('cell_type' in c) || !VALID_CELL_TYPES.has(c['cell_type'])) {
-            return { valid: false, error: `Cell ${i} has missing or invalid 'cell_type' (must be 'code', 'markdown', or 'raw')` };
-        }
-        if (!('source' in c) || (typeof c['source'] !== 'string' && !Array.isArray(c['source']))) {
-            return { valid: false, error: `Cell ${i} must have a 'source' field (string or array)` };
-        }
-        if (c['cell_type'] === 'code') {
-            if ('outputs' in c && !Array.isArray(c['outputs'])) {
-                return { valid: false, error: `Cell ${i} 'outputs' must be an array` };
-            }
-            if ('execution_count' in c && c['execution_count'] !== null && typeof c['execution_count'] !== 'number') {
-                return { valid: false, error: `Cell ${i} 'execution_count' must be a number or null` };
-            }
-        }
-    }
-    return { valid: true, notebook: nb };
-}
-/**
- * Atomically write content to a file.
- * Writes to a temp file first, then renames to the target path.
- */
-function atomicWrite(targetPath, content, encoding = 'utf-8') {
-    const rand = randomBytes(4).toString('hex');
-    const tmpPath = `${targetPath}.tmp.${rand}`;
-    try {
-        writeFileSync(tmpPath, content, { encoding });
-        renameSync(tmpPath, targetPath);
-    }
-    catch (err) {
-        // Clean up temp file if rename failed
-        try {
-            unlinkSync(tmpPath);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        throw err;
-    }
-}
-// ---------------------------------------------------------------------------
-// Core write logic
-// ---------------------------------------------------------------------------
-/**
- * Process a single file write entry.
- * Returns null if successful (mutates results array) or a string error message.
- */
-function processSingleWrite(fileInput, projectRoot, dryRun) {
-    // Resolve and validate path
-    let resolvedPath;
-    try {
-        resolvedPath = resolveAndValidatePath(fileInput.path, projectRoot);
-    }
-    catch (err) {
-        return { ok: false, error: `Path error for '${fileInput.path}': ${summarizeError(err)}` };
-    }
-    const mode = fileInput.mode ?? 'fail_if_exists';
-    // Validate encoding
-    const VALID_ENCODINGS = new Set(['utf-8', 'utf8', 'ascii', 'latin1', 'base64', 'hex', 'binary']);
-    if (fileInput.encoding && !VALID_ENCODINGS.has(fileInput.encoding)) {
-        return {
-            ok: false,
-            error: `Invalid encoding: '${fileInput.encoding}'. Valid: ${[...VALID_ENCODINGS].join(', ')}`,
-        };
-    }
-    const encoding = fileInput.encoding ?? 'utf-8';
-    // Validate base64 input
-    if (fileInput.content_base64 !== undefined) {
-        const b64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
-        if (!b64Regex.test(fileInput.content_base64.replace(/\s/g, ''))) {
-            return {
-                ok: false,
-                error: `Invalid base64 content for '${fileInput.path}': content is not valid base64.`,
-            };
-        }
-    }
-    let content = resolveContent(fileInput);
-    // Notebook validation and normalization
-    if (isNotebookFile(resolvedPath)) {
-        const validation = validateNotebookContent(content);
-        if (!validation.valid) {
-            return {
-                ok: false,
-                error: `Invalid notebook content for '${fileInput.path}': ${validation.error}`,
-            };
-        }
-        // Re-serialize with consistent formatting (1-space indent, trailing newline).
-        // Use the already-parsed notebook from the validator to avoid a redundant JSON.parse.
-        content = JSON.stringify(validation.notebook, null, 1) + '\n';
-    }
-    const byteSize = Buffer.byteLength(content, encoding);
-    // Check existence
-    const alreadyExists = existsSync(resolvedPath);
-    if (alreadyExists && mode === 'fail_if_exists') {
-        return {
-            ok: false,
-            error: `File already exists: '${fileInput.path}'. Use mode 'overwrite' or 'backup' to replace it.`,
-        };
-    }
-    const result = {
-        path: fileInput.path,
-        resolved_path: resolvedPath,
-        bytes_written: byteSize,
-        mode_applied: mode,
-        _content: content,
-    };
-    if (dryRun) {
-        result.would_write = true;
-        if (alreadyExists && mode === 'backup') {
-            result.backup_path = buildBackupPath(resolvedPath, projectRoot);
-        }
-        return { ok: true, result };
-    }
-    // Backup if needed
-    if (alreadyExists && mode === 'backup') {
-        const backupPath = buildBackupPath(resolvedPath, projectRoot);
-        try {
-            mkdirSync(dirname(backupPath), { recursive: true });
-            copyFileSync(resolvedPath, backupPath);
-            result.backup_path = backupPath;
-        }
-        catch (err) {
-            return {
-                ok: false,
-                error: `Backup failed for '${fileInput.path}': ${summarizeError(err)}`,
-            };
-        }
-    }
-    // Auto-create parent directories
-    try {
-        mkdirSync(dirname(resolvedPath), { recursive: true });
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: `Failed to create parent directories for '${fileInput.path}': ${summarizeError(err)}`,
-        };
-    }
-    // Atomic write
-    try {
-        atomicWrite(resolvedPath, content, encoding);
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: `Write failed for '${fileInput.path}': ${summarizeError(err)}`,
-        };
-    }
-    return { ok: true, result };
-}
-// ---------------------------------------------------------------------------
-// Format output
-// ---------------------------------------------------------------------------
-function formatOutput(results, errors, verbosity, dryRun) {
-    const totalBytes = results.reduce((acc, r) => acc + r.bytes_written, 0);
-    const base = {
-        files_written: results.length,
-        bytes_written: totalBytes,
-    };
-    if (dryRun) {
-        base.dry_run = true;
-    }
-    if (verbosity === 'count_only') {
-        return base;
-    }
-    if (verbosity === 'minimal') {
-        base.files = results.map(({ _content: _, ...r }) => ({
-            path: r.path,
-            resolved_path: r.resolved_path,
-            bytes_written: r.bytes_written,
-            mode_applied: r.mode_applied,
-            ...(r.backup_path ? { backup_path: r.backup_path } : {}),
-            ...(r.would_write ? { would_write: r.would_write } : {}),
-        }));
-        return base;
-    }
-    // standard and verbose both include full results (strip internal _content field)
-    base.files = results.map(({ _content: _, ...r }) => r);
-    return base;
-}
-// ---------------------------------------------------------------------------
-// Tool factory
-// ---------------------------------------------------------------------------
-export function createWriteTool(options) {
-    if (typeof options?.projectRoot !== 'string' || options.projectRoot.trim().length === 0) {
-        throw new Error('createWriteTool requires projectRoot');
-    }
-    const projectRoot = options.projectRoot;
-    const definition = {
-        name: 'write',
-        description: 'Write one or more files to disk. Supports batch writes, automatic parent directory creation, ' +
-            'and three overwrite modes: fail_if_exists (default), overwrite, backup. ' +
-            'Use content_base64 for content containing special characters.',
-        parameters: WRITE_SCHEMA,
-        sideEffects: ['write_fs'],
-        concurrency: 'serial',
-        supportsProgress: true,
-    };
-    return {
-        definition,
-        async execute(args) {
-            // Runtime validation before cast: ensure required fields exist.
-            if (!args['files'] || !Array.isArray(args['files']) || args['files'].length === 0) {
-                return {
-                    success: false,
-                    error: "Invalid input: 'files' must be a non-empty array.",
-                };
-            }
-            const input = args;
-            const verbosity = input.verbosity ?? 'count_only';
-            const dryRun = input.dry_run ?? false;
-            const results = [];
-            const errors = [];
-            const transactionMode = input.transaction?.mode ?? 'none';
-            // Snapshots for atomic rollback: map from resolvedPath -> original content (null = new file)
-            const snapshots = new Map();
-            for (const fileInput of input.files) {
-                if (!fileInput.path || typeof fileInput.path !== 'string') {
-                    errors.push(`Invalid file entry: missing or invalid 'path' field.`);
-                    continue;
-                }
-                // Capture before-content for undo and atomic transaction snapshots BEFORE the write happens
-                let beforeContent = null;
-                if (!dryRun && fileInput.path) {
-                    let resolvedForUndo;
-                    try {
-                        resolvedForUndo = resolveAndValidatePath(fileInput.path, projectRoot);
-                    }
-                    catch {
-                        resolvedForUndo = undefined;
-                    }
-                    if (resolvedForUndo && existsSync(resolvedForUndo)) {
-                        try {
-                            beforeContent = readFileSync(resolvedForUndo, 'utf-8');
-                        }
-                        catch {
-                            beforeContent = null;
-                        }
-                    }
-                    // Store snapshot for atomic transaction rollback
-                    if (transactionMode === 'atomic' && resolvedForUndo && !snapshots.has(resolvedForUndo)) {
-                        snapshots.set(resolvedForUndo, beforeContent);
-                    }
-                }
-                const outcome = processSingleWrite(fileInput, projectRoot, dryRun);
-                if (!outcome.ok) {
-                    errors.push(outcome.error);
-                    logger.debug('write tool: file write failed', { path: fileInput.path, error: outcome.error });
-                    // Atomic transaction: rollback all successfully written files
-                    if (transactionMode === 'atomic' && results.length > 0) {
-                        const rolledBack = [];
-                        for (const written of results) {
-                            try {
-                                const snapshot = snapshots.get(written.resolved_path);
-                                if (snapshot === null || snapshot === undefined) {
-                                    // File was new - delete it
-                                    unlinkSync(written.resolved_path);
-                                }
-                                else {
-                                    // File existed before - restore original
-                                    atomicWrite(written.resolved_path, snapshot);
-                                }
-                                rolledBack.push(written.path);
-                            }
-                            catch (rollbackErr) {
-                                logger.debug('write tool: atomic rollback failed (non-fatal)', {
-                                    path: written.resolved_path,
-                                    error: String(rollbackErr),
-                                });
-                            }
-                        }
-                        const failMsg = `Atomic transaction failed on '${fileInput.path}': ${outcome.error}. Rolled back ${rolledBack.length} file(s): ${rolledBack.join(', ')}`;
-                        return {
-                            success: false,
-                            error: failMsg,
-                        };
-                    }
-                    continue;
-                }
-                results.push(outcome.result);
-                // State integration — only for real writes, not dry runs
-                if (!dryRun) {
-                    let content = outcome.result._content ?? '';
-                    // Auto-heal: if file is JS/TS and auto-heal is enabled, run syntax check
-                    if (options?.configManager?.get('tools.autoHeal')) {
-                        const ext = extname(outcome.result.resolved_path).toLowerCase();
-                        const isJsTs = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'].includes(ext);
-                        if (isJsTs) {
-                            try {
-                                const loader = (ext === '.mjs' || ext === '.cjs') ? 'js' : ext.slice(1);
-                                const transpiler = new Bun.Transpiler({ loader });
-                                transpiler.transformSync(content);
-                            }
-                            catch (syntaxErr) {
-                                const syntaxErrors = [String(syntaxErr)];
-                                const healResult = options.toolLLM && options.configManager
-                                    ? await new AutoHealer(options.configManager, options.toolLLM).heal(outcome.result.resolved_path, content, syntaxErrors)
-                                    : { healed: false, content };
-                                if (healResult.healed) {
-                                    logger.debug('write tool: auto-heal succeeded', {
-                                        path: outcome.result.resolved_path,
-                                        method: healResult.method,
-                                    });
-                                    content = healResult.content;
-                                    // Rewrite file with healed content
-                                    try {
-                                        atomicWrite(outcome.result.resolved_path, content);
-                                    }
-                                    catch (writeErr) {
-                                        logger.debug('write tool: auto-heal rewrite failed (non-fatal)', {
-                                            path: outcome.result.resolved_path,
-                                            error: String(writeErr),
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    const byteSize = Buffer.byteLength(content, 'utf-8');
-                    const tokenEstimate = Math.ceil(byteSize / 4);
-                    if (options?.fileCache) {
-                        try {
-                            options.fileCache.update(outcome.result.resolved_path, content, { tool: 'write' });
-                        }
-                        catch (err) {
-                            logger.debug('write tool: fileCache.update failed (non-fatal)', {
-                                path: outcome.result.resolved_path,
-                                error: summarizeError(err),
-                            });
-                        }
-                    }
-                    if (options?.projectIndex) {
-                        try {
-                            options.projectIndex.upsertFile(outcome.result.resolved_path, tokenEstimate);
-                        }
-                        catch (err) {
-                            logger.debug('write tool: projectIndex.upsertFile failed (non-fatal)', {
-                                path: outcome.result.resolved_path,
-                                error: summarizeError(err),
-                            });
-                        }
-                    }
-                    // Snapshot for /undo file support
-                    if (options?.fileUndoManager) {
-                        try {
-                            options.fileUndoManager.snapshot({
-                                path: outcome.result.resolved_path,
-                                beforeContent,
-                                afterContent: content,
-                                tool: 'write',
-                            });
-                        }
-                        catch (err) {
-                            logger.debug('write tool: fileUndoManager.snapshot failed (non-fatal)', {
-                                path: outcome.result.resolved_path,
-                                error: summarizeError(err),
-                            });
-                        }
-                    }
-                    logger.debug('write tool: wrote file', {
-                        path: outcome.result.resolved_path,
-                        bytes: byteSize,
-                        mode: outcome.result.mode_applied,
-                    });
-                    // Track for /diff session change view
-                    options?.changeTracker?.recordChange(outcome.result.resolved_path);
-                }
-            }
-            if (errors.length > 0 && results.length === 0) {
-                return {
-                    success: false,
-                    error: errors.join('\n'),
-                };
-            }
-            const output = formatOutput(results, errors, verbosity, dryRun);
-            // Attach partial errors to output if some succeeded and some failed
-            const finalOutput = { ...output };
-            if (errors.length > 0) {
-                finalOutput.errors = errors;
-            }
-            // Post-write validation — run after all files are written, even if partial errors occurred
-            if (!dryRun && results.length > 0 && input.validate?.after && input.validate.after.length > 0) {
-                const validatorNames = input.validate.after;
-                logger.debug('write tool: running post-write validators', { validators: validatorNames });
-                try {
-                    const failures = await runValidators(validatorNames, projectRoot);
-                    if (failures.length > 0) {
-                        finalOutput.validation_failures = failures.map((f) => ({
-                            validator: f.validator,
-                            passed: false,
-                            exit_code: f.exitCode,
-                            stdout: f.stdout.trim(),
-                            stderr: f.stderr.trim(),
-                            message: formatValidatorFailure(f),
-                        }));
-                        logger.debug('write tool: post-write validators failed', {
-                            count: failures.length,
-                            validators: failures.map((f) => f.validator),
-                        });
-                    }
-                    else {
-                        finalOutput.validation_passed = true;
-                    }
-                }
-                catch (validationErr) {
-                    logger.debug('write tool: validator execution error (non-fatal)', { error: String(validationErr) });
-                    finalOutput.validation_error = String(validationErr);
-                }
-            }
-            return {
-                success: errors.length === 0,
-                output: JSON.stringify(finalOutput),
-            };
-        },
-    };
-}

package/dist/_internal/platform/tools/write/phased.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"phased.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/write/phased.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMhE,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAMD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,SAAc,uDAG9E"}