@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/edit/notebook.js

@@ -0,0 +1,265 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { isNotebookFile } from '../../utils/notebook.js';
+import { unifiedDiff, FileStateCache } from '../../state/file-cache.js';
+import { FileUndoManager } from '../../state/file-undo.js';
+import { logger } from '../../utils/logger.js';
+import { resolveAndValidatePath } from '../../utils/path-safety.js';
+import { summarizeError } from '../../utils/error-display.js';
+export function normalizeSource(source) {
+    if (Array.isArray(source))
+        return source;
+    const lines = source.split('\n');
+    return lines.map((line, i) => (i < lines.length - 1 ? line + '\n' : line));
+}
+export function validateNotebook(parsed) {
+    if (typeof parsed !== 'object' || parsed === null)
+        return false;
+    const nb = parsed;
+    if (typeof nb['nbformat'] !== 'number')
+        return false;
+    if (!Array.isArray(nb['cells']))
+        return false;
+    for (const cell of nb['cells']) {
+        if (!cell || typeof cell !== 'object')
+            return false;
+        const c = cell;
+        if (!c['cell_type'] || typeof c['cell_type'] !== 'string')
+            return false;
+        if (c['source'] === undefined)
+            return false;
+    }
+    return true;
+}
+export function resolveCellId(cells, cellId) {
+    for (let i = 0; i < cells.length; i++) {
+        const cell = cells[i];
+        if (cell.id === cellId)
+            return i;
+        if (cell.metadata && cell.metadata['id'] === cellId)
+            return i;
+    }
+    return -1;
+}
+export function generateCellId(existingCells) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    const existingIds = new Set(existingCells?.map((c) => c.id).filter(Boolean) ?? []);
+    let id;
+    do {
+        id = Array.from({ length: 8 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+    } while (existingIds.has(id));
+    return id;
+}
+export function readNotebookFile(resolvedPath, fileCache) {
+    const cacheResult = fileCache.lookup(resolvedPath);
+    if (cacheResult.status === 'modified') {
+        return { error: `OCC conflict: '${resolvedPath}' was modified externally since last read` };
+    }
+    let rawContent;
+    try {
+        rawContent = readFileSync(resolvedPath, 'utf-8');
+    }
+    catch {
+        return { error: `File not found or unreadable: '${resolvedPath}'` };
+    }
+    try {
+        const parsed = JSON.parse(rawContent);
+        if (!validateNotebook(parsed)) {
+            return { error: 'Not a valid Jupyter notebook: missing nbformat or cells array' };
+        }
+        return { notebook: parsed, rawContent };
+    }
+    catch (err) {
+        return { error: `Failed to parse notebook JSON: ${summarizeError(err)}` };
+    }
+}
+export function applyNotebookOperations(notebook, operations) {
+    const needsCellIds = notebook.nbformat > 4 ||
+        (notebook.nbformat === 4 && (notebook.nbformat_minor ?? 0) >= 5);
+    let indexOffset = 0;
+    let applied = 0;
+    const summaryLines = [];
+    for (const op of operations) {
+        if (op.op === 'replace') {
+            let idx;
+            if (op.cell_id !== undefined) {
+                idx = resolveCellId(notebook.cells, op.cell_id);
+                if (idx === -1) {
+                    return { success: false, applied, summary: summaryLines.join('\n'), error: `replace: cell_id '${op.cell_id}' not found` };
+                }
+            }
+            else if (op.cell !== undefined) {
+                idx = op.cell + indexOffset;
+                if (idx < 0 || idx >= notebook.cells.length) {
+                    return { success: false, applied, summary: summaryLines.join('\n'), error: `replace: cell index ${op.cell} out of range (notebook has ${notebook.cells.length} cells)` };
+                }
+            }
+            else {
+                return { success: false, applied, summary: summaryLines.join('\n'), error: 'replace: requires cell or cell_id' };
+            }
+            if (op.source === undefined) {
+                return { success: false, applied, summary: summaryLines.join('\n'), error: 'replace: source is required' };
+            }
+            const cell = notebook.cells[idx];
+            cell.source = normalizeSource(op.source);
+            if (op.cell_type !== undefined && op.cell_type !== cell.cell_type) {
+                cell.cell_type = op.cell_type;
+                if (op.cell_type === 'code') {
+                    if (cell.execution_count === undefined)
+                        cell.execution_count = null;
+                    if (cell.outputs === undefined)
+                        cell.outputs = [];
+                }
+                else {
+                    delete cell.execution_count;
+                    delete cell.outputs;
+                }
+            }
+            if (op.clear_outputs && cell.cell_type === 'code') {
+                cell.outputs = [];
+                cell.execution_count = null;
+            }
+            summaryLines.push(`  OK: replace cell[${idx}]`);
+            applied++;
+        }
+        else if (op.op === 'insert') {
+            if (op.source === undefined) {
+                return { success: false, applied, summary: summaryLines.join('\n'), error: 'insert: source is required' };
+            }
+            if (op.cell_type === undefined) {
+                return { success: false, applied, summary: summaryLines.join('\n'), error: 'insert: cell_type is required' };
+            }
+            const newCell = {
+                cell_type: op.cell_type,
+                source: normalizeSource(op.source),
+                metadata: {},
+            };
+            if (op.cell_type === 'code') {
+                newCell.execution_count = null;
+                newCell.outputs = [];
+            }
+            if (needsCellIds) {
+                newCell.id = generateCellId(notebook.cells);
+            }
+            let insertAt;
+            if (op.cell_id !== undefined) {
+                const refIdx = resolveCellId(notebook.cells, op.cell_id);
+                if (refIdx === -1) {
+                    return { success: false, applied, summary: summaryLines.join('\n'), error: `insert: cell_id '${op.cell_id}' not found` };
+                }
+                insertAt = refIdx + 1;
+            }
+            else if (op.after !== undefined) {
+                if (op.after === -1) {
+                    insertAt = 0;
+                }
+                else {
+                    const adjustedAfter = op.after + indexOffset;
+                    if (adjustedAfter < -1 || adjustedAfter >= notebook.cells.length) {
+                        return { success: false, applied, summary: summaryLines.join('\n'), error: `insert: after index ${op.after} out of bounds (-1 to ${notebook.cells.length - 1})` };
+                    }
+                    insertAt = adjustedAfter + 1;
+                }
+            }
+            else {
+                insertAt = notebook.cells.length;
+            }
+            notebook.cells.splice(insertAt, 0, newCell);
+            indexOffset++;
+            summaryLines.push(`  OK: insert cell at[${insertAt}]`);
+            applied++;
+        }
+        else if (op.op === 'delete') {
+            let idx;
+            if (op.cell_id !== undefined) {
+                idx = resolveCellId(notebook.cells, op.cell_id);
+                if (idx === -1) {
+                    return { success: false, applied, summary: summaryLines.join('\n'), error: `delete: cell_id '${op.cell_id}' not found` };
+                }
+            }
+            else if (op.cell !== undefined) {
+                idx = op.cell + indexOffset;
+                if (idx < 0 || idx >= notebook.cells.length) {
+                    return { success: false, applied, summary: summaryLines.join('\n'), error: `delete: cell index ${op.cell} out of range (notebook has ${notebook.cells.length} cells)` };
+                }
+            }
+            else {
+                return { success: false, applied, summary: summaryLines.join('\n'), error: 'delete: requires cell or cell_id' };
+            }
+            notebook.cells.splice(idx, 1);
+            indexOffset--;
+            summaryLines.push(`  OK: delete cell[${idx}]`);
+            applied++;
+        }
+    }
+    return { success: true, applied, summary: summaryLines.join('\n') };
+}
+export function formatNotebookOutput(opsResult, outputFormat, dryRun, rawContent, newContent, resolvedPath, diffContext) {
+    if (outputFormat === 'count_only') {
+        return JSON.stringify({ applied: opsResult.applied, failed: 0, dry_run: dryRun });
+    }
+    if (outputFormat === 'minimal') {
+        return `Notebook operations applied: ${opsResult.applied}, failed: 0${dryRun ? ' (dry run)' : ''}\n${opsResult.summary}`;
+    }
+    const diff = unifiedDiff(rawContent, newContent, resolvedPath, diffContext);
+    return `Notebook operations applied: ${opsResult.applied}, failed: 0${dryRun ? ' (dry run)' : ''}\n${opsResult.summary}\n${diff}`;
+}
+export function executeNotebookEdit(input, env) {
+    const nbOps = input.notebook_operations;
+    const outputFormat = input.output?.format ?? 'minimal';
+    const diffContext = input.output?.diff_context ?? 3;
+    const dryRun = input.dry_run ?? false;
+    if (!nbOps.path || typeof nbOps.path !== 'string') {
+        return Promise.resolve({ success: false, error: 'notebook_operations.path is required and must be a string' });
+    }
+    if (!Array.isArray(nbOps.operations)) {
+        return Promise.resolve({ success: false, error: 'notebook_operations.operations must be an array' });
+    }
+    let resolvedPath;
+    try {
+        resolvedPath = resolveAndValidatePath(nbOps.path, env.cwd);
+    }
+    catch (err) {
+        return Promise.resolve({ success: false, error: `Path error: ${summarizeError(err)}` });
+    }
+    if (!isNotebookFile(resolvedPath)) {
+        return Promise.resolve({ success: false, error: `notebook_operations requires a .ipynb file, got: ${nbOps.path}` });
+    }
+    const notebookRead = readNotebookFile(resolvedPath, env.fileCache);
+    if ('error' in notebookRead) {
+        return Promise.resolve({ success: false, error: notebookRead.error });
+    }
+    const notebook = notebookRead.notebook;
+    const rawContent = notebookRead.rawContent;
+    const opsResult = applyNotebookOperations(notebook, nbOps.operations);
+    if (!opsResult.success) {
+        return Promise.resolve({ success: false, error: opsResult.error });
+    }
+    const newContent = JSON.stringify(notebook, null, 1) + '\n';
+    if (dryRun) {
+        return Promise.resolve({ success: true, output: formatNotebookOutput(opsResult, outputFormat, true, rawContent, newContent, resolvedPath, diffContext) });
+    }
+    try {
+        writeFileSync(resolvedPath, newContent, 'utf-8');
+    }
+    catch (err) {
+        return Promise.resolve({ success: false, error: `Write failed for '${resolvedPath}': ${summarizeError(err)}` });
+    }
+    env.fileCache.update(resolvedPath, newContent);
+    if (env.fileUndoManager) {
+        try {
+            env.fileUndoManager.snapshot({
+                path: resolvedPath,
+                beforeContent: rawContent,
+                afterContent: newContent,
+                tool: 'edit',
+            });
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    return Promise.resolve({
+        success: true,
+        output: formatNotebookOutput(opsResult, outputFormat, false, rawContent, newContent, resolvedPath, diffContext),
+    });
+}

package/dist/platform/tools/edit/schema.d.ts

@@ -0,0 +1,222 @@
+/** JSON Schema definition for the edit tool input. */
+export declare const editSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly edits: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["path", "find", "replace"];
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                        readonly description: "File path to edit (relative to project root or absolute within it)";
+                    };
+                    readonly find: {
+                        readonly type: "string";
+                        readonly description: "Text to find in the file";
+                    };
+                    readonly find_base64: {
+                        readonly type: "string";
+                        readonly description: "Base64-encoded text to find (alternative to find for binary-safe transport)";
+                    };
+                    readonly replace: {
+                        readonly type: "string";
+                        readonly description: "Replacement text";
+                    };
+                    readonly replace_base64: {
+                        readonly type: "string";
+                        readonly description: "Base64-encoded replacement text (alternative to replace for binary-safe transport)";
+                    };
+                    readonly id: {
+                        readonly type: "string";
+                        readonly description: "Optional identifier for this edit, used in result tracking";
+                    };
+                    readonly occurrence: {
+                        readonly oneOf: readonly [{
+                            readonly type: "string";
+                            readonly enum: readonly ["first", "last", "all"];
+                            readonly description: "Which occurrence to replace: first, last, or all";
+                        }, {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                            readonly description: "Replace the Nth occurrence (1-based)";
+                        }];
+                        readonly description: string;
+                    };
+                    readonly hints: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly near_line: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                                readonly description: "Prefer the occurrence closest to this line number";
+                            };
+                            readonly in_function: {
+                                readonly type: "string";
+                                readonly description: "Only match within a function with this name";
+                            };
+                            readonly in_class: {
+                                readonly type: "string";
+                                readonly description: "Only match within a class with this name";
+                            };
+                            readonly after: {
+                                readonly type: "string";
+                                readonly description: "Only match occurrences that appear after this text anchor in the file";
+                            };
+                            readonly before: {
+                                readonly type: "string";
+                                readonly description: "Only match occurrences that appear before this text anchor in the file";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly match: {
+            readonly type: "object";
+            readonly properties: {
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["exact", "fuzzy", "regex", "ast", "ast_pattern"];
+                    readonly description: string;
+                    readonly default: "exact";
+                };
+                readonly case_sensitive: {
+                    readonly type: "boolean";
+                    readonly description: "Whether matching is case-sensitive. Default: true.";
+                    readonly default: true;
+                };
+                readonly whitespace_sensitive: {
+                    readonly type: "boolean";
+                    readonly description: "Whether whitespace differences matter. When false in exact mode, delegates to fuzzy matching algorithm. Default: true.";
+                    readonly default: true;
+                };
+                readonly multiline: {
+                    readonly type: "boolean";
+                    readonly description: string;
+                    readonly default: false;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly transaction: {
+            readonly type: "object";
+            readonly properties: {
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["atomic", "partial", "none"];
+                    readonly description: string;
+                    readonly default: "atomic";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly output: {
+            readonly type: "object";
+            readonly properties: {
+                readonly format: {
+                    readonly type: "string";
+                    readonly enum: readonly ["count_only", "minimal", "with_diff", "verbose"];
+                    readonly description: string;
+                    readonly default: "minimal";
+                };
+                readonly diff_context: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly description: string;
+                    readonly default: 3;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly dry_run: {
+            readonly type: "boolean";
+            readonly description: "Compute all replacements and return diffs without writing to disk. Default: false.";
+            readonly default: false;
+        };
+        readonly validate: {
+            readonly type: "object";
+            readonly description: "Run validators before and/or after applying edits.";
+            readonly properties: {
+                readonly before: {
+                    readonly type: "array";
+                    readonly description: "Validators to run before applying edits. If any fail, edits are not applied.";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly enum: readonly ["typecheck", "lint", "test", "build"];
+                    };
+                };
+                readonly after: {
+                    readonly type: "array";
+                    readonly description: "Validators to run after applying edits. If any fail in atomic mode, edits are rolled back.";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly enum: readonly ["typecheck", "lint", "test", "build"];
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly notebook_operations: {
+            readonly type: "object";
+            readonly description: "Jupyter notebook (.ipynb) cell operations. Alternative to edits — provide either edits or notebook_operations, not both.";
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                    readonly description: "Path to .ipynb notebook file";
+                };
+                readonly operations: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["op"];
+                        readonly properties: {
+                            readonly op: {
+                                readonly type: "string";
+                                readonly enum: readonly ["replace", "insert", "delete"];
+                                readonly description: "Cell operation: replace existing cell content, insert a new cell, or delete a cell";
+                            };
+                            readonly cell: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly description: "0-based cell index (used by replace/delete when cell_id is not provided)";
+                            };
+                            readonly cell_id: {
+                                readonly type: "string";
+                                readonly description: "Cell ID targeting — takes precedence over cell index for all operations";
+                            };
+                            readonly after: {
+                                readonly type: "integer";
+                                readonly minimum: -1;
+                                readonly description: "For insert: insert after this 0-based index (-1 = insert at beginning). Omit to append at end.";
+                            };
+                            readonly source: {
+                                readonly type: "string";
+                                readonly description: "Cell source content (required for replace and insert operations)";
+                            };
+                            readonly cell_type: {
+                                readonly type: "string";
+                                readonly enum: readonly ["code", "markdown", "raw"];
+                                readonly description: "Cell type (required for insert; optional for replace — if provided, changes the cell type)";
+                            };
+                            readonly clear_outputs: {
+                                readonly type: "boolean";
+                                readonly description: "Clear cell outputs on replace (default: false)";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+            };
+            readonly required: readonly ["path", "operations"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly additionalProperties: false;
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/edit/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/edit/schema.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgPb,CAAC"}