@iaforged/context-code 1.2.8 → 1.2.10

package/dist/src/core/tools/fileResolution.js

@@ -0,0 +1,112 @@
+// Helpers puros de resolucion/sugerencia de paths para FileReadTool.
+//
+// Estos vivian dispersos en `utils/file.ts`, `utils/pdfUtils.ts` y dentro de
+// `tools/FileReadTool/FileReadTool.ts`. La meta de Fase 6 es que el `core/`
+// no dependa de globals del CLI (`getCwd`, `getFsImplementation`, modelo
+// activo). Aqui aceptamos esas dependencias por parametro o por context.
+import { dirname, basename, extname, join, relative, sep } from 'path';
+import { realpath, stat } from 'fs/promises';
+const REGULAR_SPACE = ' ';
+const THIN_SPACE = ' ';
+// ── Document extension helpers ──────────────────────────────────────────────
+export const CORE_DOCUMENT_EXTENSIONS = new Set(['pdf']);
+export function isPDFExtension(ext) {
+    const normalized = ext.startsWith('.') ? ext.slice(1) : ext;
+    return CORE_DOCUMENT_EXTENSIONS.has(normalized.toLowerCase());
+}
+// ── PDF page range parsing (puro string) ────────────────────────────────────
+export function parsePDFPageRange(pages) {
+    const trimmed = pages.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // "N-" open-ended range
+    if (trimmed.endsWith('-')) {
+        const first = parseInt(trimmed.slice(0, -1), 10);
+        if (isNaN(first) || first < 1) {
+            return null;
+        }
+        return { firstPage: first, lastPage: Infinity };
+    }
+    const dashIndex = trimmed.indexOf('-');
+    if (dashIndex === -1) {
+        const page = parseInt(trimmed, 10);
+        if (isNaN(page) || page < 1) {
+            return null;
+        }
+        return { firstPage: page, lastPage: page };
+    }
+    const first = parseInt(trimmed.slice(0, dashIndex), 10);
+    const last = parseInt(trimmed.slice(dashIndex + 1), 10);
+    if (isNaN(first) || isNaN(last) || first < 1 || last < 1 || last < first) {
+        return null;
+    }
+    return { firstPage: first, lastPage: last };
+}
+// ── macOS screenshot AM/PM space variant ────────────────────────────────────
+//
+// Para macOS, los screenshots a veces usan espacio normal y otras un thin
+// space (U+202F) antes de AM/PM. Esto tira ENOENT al leer si el modelo
+// adivina mal el espacio. Devolvemos el path alternativo si aplica.
+export function getAlternateScreenshotPath(filePath) {
+    const filename = basename(filePath);
+    const amPmPattern = new RegExp(`^(.+)([${REGULAR_SPACE}${THIN_SPACE}])(AM|PM)(\\.png)$`);
+    const match = filename.match(amPmPattern);
+    if (!match)
+        return undefined;
+    const currentSpace = match[2];
+    const alternateSpace = currentSpace === REGULAR_SPACE ? THIN_SPACE : REGULAR_SPACE;
+    return filePath.replace(`${currentSpace}${match[3]}${match[4]}`, `${alternateSpace}${match[3]}${match[4]}`);
+}
+export function findSimilarFile(filePath, readdirSync, isENOENT, logError) {
+    try {
+        const dir = dirname(filePath);
+        const fileBaseName = basename(filePath, extname(filePath));
+        const files = readdirSync(dir);
+        const similarFiles = files.filter(file => basename(file.name, extname(file.name)) === fileBaseName &&
+            join(dir, file.name) !== filePath);
+        const firstMatch = similarFiles[0];
+        if (firstMatch) {
+            return firstMatch.name;
+        }
+        return undefined;
+    }
+    catch (error) {
+        if (!isENOENT(error)) {
+            logError(error);
+        }
+        return undefined;
+    }
+}
+// ── Path-under-cwd suggestion (dropped repo folder) ─────────────────────────
+//
+// Patron comun: el modelo construye un path absoluto omitiendo el directorio
+// del repo. Si el path no existe pero existe `cwd/<rel>`, devolvemos esa
+// version. cwd se inyecta para evitar dependencia con `process.cwd()` global.
+export const FILE_NOT_FOUND_CWD_NOTE = 'Note: your current working directory is';
+export async function suggestPathUnderCwd(requestedPath, cwd) {
+    const cwdParent = dirname(cwd);
+    let resolvedPath = requestedPath;
+    try {
+        const resolvedDir = await realpath(dirname(requestedPath));
+        resolvedPath = join(resolvedDir, basename(requestedPath));
+    }
+    catch {
+        // Parent directory doesn't exist, use the original path
+    }
+    const cwdParentPrefix = cwdParent === sep ? sep : cwdParent + sep;
+    if (!resolvedPath.startsWith(cwdParentPrefix) ||
+        resolvedPath.startsWith(cwd + sep) ||
+        resolvedPath === cwd) {
+        return undefined;
+    }
+    const relFromParent = relative(cwdParent, resolvedPath);
+    const correctedPath = join(cwd, relFromParent);
+    try {
+        await stat(correctedPath);
+        return correctedPath;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/core/tools/fileResolution.smoke.js

@@ -0,0 +1,33 @@
+// Smoke de helpers puros del core/tools.
+//
+// Garantiza paridad con la logica original de FileReadTool sin requerir
+// dependencias del CLI (modelo, fs global, etc).
+import assert from 'node:assert/strict';
+import { parsePDFPageRange, isPDFExtension, getAlternateScreenshotPath, } from './fileResolution.js';
+// ── parsePDFPageRange ──
+assert.deepEqual(parsePDFPageRange('5'), { firstPage: 5, lastPage: 5 });
+assert.deepEqual(parsePDFPageRange('1-10'), { firstPage: 1, lastPage: 10 });
+assert.deepEqual(parsePDFPageRange('3-'), { firstPage: 3, lastPage: Infinity });
+assert.equal(parsePDFPageRange(''), null, 'empty input');
+assert.equal(parsePDFPageRange('abc'), null, 'non-numeric');
+assert.equal(parsePDFPageRange('0'), null, 'zero rejected');
+assert.equal(parsePDFPageRange('10-1'), null, 'inverted range');
+assert.equal(parsePDFPageRange('-5'), null, 'leading dash');
+// ── isPDFExtension ──
+assert.equal(isPDFExtension('pdf'), true);
+assert.equal(isPDFExtension('.pdf'), true);
+assert.equal(isPDFExtension('PDF'), true);
+assert.equal(isPDFExtension('txt'), false);
+assert.equal(isPDFExtension(''), false);
+// ── getAlternateScreenshotPath ──
+const regularSpace = ' ';
+const thinSpace = ' ';
+const regularPath = `/tmp/Screenshot 2024-01-01 at 12.00.00${regularSpace}AM.png`;
+const expectedAlt = `/tmp/Screenshot 2024-01-01 at 12.00.00${thinSpace}AM.png`;
+assert.equal(getAlternateScreenshotPath(regularPath), expectedAlt, 'regular -> thin space variant');
+const thinPath = `/tmp/Screenshot 2024-01-01 at 12.00.00${thinSpace}PM.png`;
+const expectedAlt2 = `/tmp/Screenshot 2024-01-01 at 12.00.00${regularSpace}PM.png`;
+assert.equal(getAlternateScreenshotPath(thinPath), expectedAlt2, 'thin -> regular space variant');
+assert.equal(getAlternateScreenshotPath('/tmp/regular.png'), undefined, 'non-screenshot returns undefined');
+assert.equal(getAlternateScreenshotPath('/tmp/foo.txt'), undefined, 'non-png returns undefined');
+console.log('fileResolution smoke PASS');

package/dist/src/core/tools/filesCore.js

@@ -0,0 +1,51 @@
+import { readFileInRange } from '../../utils/readFileInRange.js';
+function normalizeOffset(offset) {
+    if (typeof offset !== 'number' || Number.isNaN(offset)) {
+        return 1;
+    }
+    return Math.max(0, Math.trunc(offset));
+}
+export async function executeCoreFileRead(input, context = {}) {
+    try {
+        const targetPath = input.absolute_path;
+        if (!targetPath) {
+            return { success: false, error: 'absolute_path is required' };
+        }
+        const startLine = normalizeOffset(input.offset);
+        const readTextFileRange = context.readTextFileRange ??
+            (async ({ absolute_path, offset, limit, max_bytes, }) => {
+                const effectiveStartLine = normalizeOffset(offset);
+                const lineOffset = effectiveStartLine === 0 ? 0 : effectiveStartLine - 1;
+                const result = await readFileInRange(absolute_path, lineOffset, limit, max_bytes, context.abortSignal);
+                return {
+                    filePath: absolute_path,
+                    content: result.content,
+                    lineCount: result.lineCount,
+                    totalLines: result.totalLines,
+                    totalBytes: result.totalBytes,
+                    readBytes: result.readBytes,
+                    mtimeMs: result.mtimeMs,
+                    startLine: effectiveStartLine,
+                };
+            });
+        const data = await readTextFileRange({
+            absolute_path: targetPath,
+            offset: startLine,
+            limit: input.limit,
+            max_bytes: input.max_bytes,
+        });
+        return {
+            success: true,
+            output: data.content,
+            data,
+        };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+export const coreFileReadTool = {
+    name: 'Read',
+    description: 'Reads text file contents from the filesystem with optional offset and limit.',
+    execute: (input, context) => executeCoreFileRead(input, context),
+};

package/dist/src/core/tools/filesCore.smoke.js

@@ -0,0 +1,108 @@
+// Smoke del orquestador executeCoreFileRead: valida que el ruteo por
+// extension elige la rama correcta y que los readers inyectables se llaman
+// con los argumentos esperados. No depende de fs real ni de poppler/sharp.
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { executeCoreFileRead } from './filesCore.js';
+// ── Texto plano: usa fs real, sin readers inyectados ──
+const tmpDir = mkdtempSync(join(tmpdir(), 'core-tools-smoke-'));
+try {
+    const txt = join(tmpDir, 'hello.txt');
+    writeFileSync(txt, 'line1\nline2\nline3\n');
+    const result = await executeCoreFileRead({ absolute_path: txt });
+    assert.equal(result.success, true, 'text read success');
+    assert.ok(result.data, 'text result has data');
+    const data = result.data;
+    assert.equal(data.type, 'text');
+    assert.match(data.content, /line1/);
+    // ── Dedup: segundo call con misma offset/limit + mtime → file_unchanged ──
+    const store = new Map();
+    const ctx = {
+        readFileState: {
+            get: (p) => store.get(p),
+            set: (p, e) => store.set(p, e),
+        },
+    };
+    const first = await executeCoreFileRead({ absolute_path: txt }, ctx);
+    assert.equal(first.success, true);
+    const second = await executeCoreFileRead({ absolute_path: txt }, ctx);
+    assert.equal(second.success, true);
+    const secondData = second.data;
+    assert.equal(secondData.type, 'file_unchanged', 'dedup hit on second read');
+}
+finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+}
+// ── Notebook: el orquestador llama al reader inyectado ──
+const notebookCalls = [];
+const notebookReader = async (path) => {
+    notebookCalls.push(path);
+    return [{ cell_type: 'code', source: 'print(1)' }];
+};
+const nbResult = await executeCoreFileRead({ absolute_path: '/fake/notebook.ipynb' }, { readNotebook: notebookReader });
+assert.equal(nbResult.success, true);
+assert.deepEqual(notebookCalls, ['/fake/notebook.ipynb']);
+const nbData = nbResult.data;
+assert.equal(nbData.type, 'notebook');
+// ── Image: el orquestador llama al reader inyectado con maxTokens default ──
+const imageCalls = [];
+const imageReader = async (p, maxTokens) => {
+    imageCalls.push({ p, max: maxTokens });
+    return {
+        type: 'image',
+        file: {
+            base64: 'AAAA',
+            mediaType: 'image/png',
+            originalSize: 4,
+        },
+    };
+};
+const imgResult = await executeCoreFileRead({ absolute_path: '/fake/photo.png' }, { readImage: imageReader });
+assert.equal(imgResult.success, true);
+assert.equal(imageCalls.length, 1);
+assert.equal(imageCalls[0].p, '/fake/photo.png');
+assert.ok(imageCalls[0].max > 0, 'maxTokens default applied');
+// ── Image sin reader: error explicito ──
+const imgFail = await executeCoreFileRead({ absolute_path: '/fake/photo.png' });
+assert.equal(imgFail.success, false);
+assert.match(imgFail.error ?? '', /readImage/);
+// ── PDF supported: usa readFull ──
+const pdfFullCalls = [];
+const pdfPagesCalls = [];
+const pdfReader = {
+    isSupported: () => true,
+    getPageCount: async () => 5,
+    readFull: async (p) => {
+        pdfFullCalls.push(p);
+        return { type: 'pdf', file: { filePath: p, base64: 'AA', originalSize: 2 } };
+    },
+    extractPages: async (p, range) => {
+        pdfPagesCalls.push({ p, range });
+        return {
+            type: 'parts',
+            file: { filePath: p, outputDir: '/tmp', count: 1, originalSize: 2 },
+        };
+    },
+};
+const pdfResult = await executeCoreFileRead({ absolute_path: '/fake/doc.pdf' }, { pdfReader });
+assert.equal(pdfResult.success, true);
+assert.equal(pdfFullCalls.length, 1, 'supported PDF goes to readFull');
+assert.equal(pdfPagesCalls.length, 0);
+// ── PDF con pages: usa extractPages con rango parseado ──
+const pdfRangeResult = await executeCoreFileRead({ absolute_path: '/fake/doc.pdf', pages: '1-3' }, { pdfReader });
+assert.equal(pdfRangeResult.success, true);
+assert.equal(pdfPagesCalls.length, 1, 'pages= triggers extractPages');
+assert.deepEqual(pdfPagesCalls[0].range, { firstPage: 1, lastPage: 3 });
+// ── PDF unsupported (modelo viejo): cae a extractPages sin rango ──
+pdfPagesCalls.length = 0;
+const unsupportedReader = {
+    ...pdfReader,
+    isSupported: () => false,
+};
+const pdfUnsupported = await executeCoreFileRead({ absolute_path: '/fake/doc2.pdf' }, { pdfReader: unsupportedReader });
+assert.equal(pdfUnsupported.success, true);
+assert.equal(pdfPagesCalls.length, 1, 'unsupported PDF falls back to extractPages');
+assert.equal(pdfPagesCalls[0].range, undefined);
+console.log('filesCore smoke PASS');

package/dist/src/core/tools/gitCore.js

@@ -0,0 +1,20 @@
+import { executeCoreShellCommand } from './shellCore.js';
+export async function executeCoreGitCommand(input, context = {}) {
+    const command = input.command;
+    if (!command) {
+        return { success: false, error: 'git command is required' };
+    }
+    if (!command.trim().startsWith('git ')) {
+        return { success: false, error: 'Only git commands are allowed.' };
+    }
+    return executeCoreShellCommand({
+        ...input,
+        shellType: input.shellType ??
+            (process.platform === 'win32' ? 'powershell' : 'bash'),
+    }, context);
+}
+export const coreGitTool = {
+    name: 'Git',
+    description: 'Executes git commands within the workspace.',
+    execute: (input, context) => executeCoreGitCommand(input, context),
+};

package/dist/src/core/tools/imageParity.smoke.js

@@ -0,0 +1,36 @@
+// Smoke E2E que valida que el orquestador del core preserva el shape
+// retornado por el reader de imagen sin transformarlo. Para evitar ciclos
+// de modulo, no importamos el adapter; usamos un reader stub que devuelve
+// un shape representativo (mismo que produce readImageWithTokenBudget).
+import assert from 'node:assert/strict';
+import { executeCoreFileRead } from './filesCore.js';
+const STUB_RESULT = {
+    type: 'image',
+    file: {
+        base64: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAA=',
+        type: 'image/png',
+        originalSize: 70,
+        dimensions: {
+            originalWidth: 1,
+            originalHeight: 1,
+            displayWidth: 1,
+            displayHeight: 1,
+        },
+    },
+};
+const calls = [];
+const reader = async (p, mt, mb) => {
+    calls.push({ p, mt, mb });
+    return STUB_RESULT;
+};
+const result = await executeCoreFileRead({ absolute_path: '/fake/photo.png', max_tokens: 12345, max_bytes: 999 }, { readImage: reader });
+assert.equal(result.success, true, 'success');
+assert.equal(calls.length, 1, 'reader called exactly once');
+assert.equal(calls[0].p, '/fake/photo.png', 'absolute_path forwarded');
+assert.equal(calls[0].mt, 12345, 'max_tokens forwarded');
+assert.equal(calls[0].mb, 999, 'max_bytes forwarded');
+const data = result.data;
+assert.equal(data.type, 'image', 'type preserved');
+assert.deepEqual(data.file, STUB_RESULT.file, 'file shape preserved 1:1');
+assert.equal(data.file.dimensions.originalWidth, STUB_RESULT.file.dimensions.originalWidth, 'dimensions preserved');
+console.log('image-parity smoke PASS');

package/dist/src/core/tools/notebookParity.smoke.js

@@ -0,0 +1,68 @@
+// Smoke E2E que valida que la lectura de notebook a traves del core
+// (executeCoreFileRead con readNotebook inyectado) produce el mismo output
+// que una lectura directa neutral del fixture.
+//
+// Este es el primer smoke de paridad ON vs OFF para tools migradas.
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { executeCoreFileRead } from './filesCore.js';
+const NOTEBOOK_FIXTURE = {
+    cells: [
+        {
+            cell_type: 'code',
+            id: 'cell-1',
+            execution_count: 1,
+            metadata: {},
+            source: ['print("hello")\n'],
+            outputs: [
+                {
+                    output_type: 'stream',
+                    name: 'stdout',
+                    text: ['hello\n'],
+                },
+            ],
+        },
+        {
+            cell_type: 'markdown',
+            id: 'cell-2',
+            metadata: {},
+            source: ['# Title\n', 'Some text\n'],
+        },
+    ],
+    metadata: {
+        language_info: { name: 'python' },
+        kernelspec: { name: 'python3', display_name: 'Python 3' },
+    },
+    nbformat: 4,
+    nbformat_minor: 5,
+};
+const tmp = mkdtempSync(join(tmpdir(), 'core-tools-nb-'));
+try {
+    const nbPath = join(tmp, 'test.ipynb');
+    writeFileSync(nbPath, JSON.stringify(NOTEBOOK_FIXTURE), 'utf8');
+    // 1) Lectura directa (parser neutral del smoke)
+    const directParsed = JSON.parse(readFileSync(nbPath, 'utf8'));
+    const direct = Array.isArray(directParsed.cells) ? directParsed.cells : [];
+    assert.ok(Array.isArray(direct), 'direct read returns array');
+    assert.equal(direct.length, 2, 'two cells');
+    // 2) Lectura a traves del core con el mismo readNotebook inyectado
+    const coreResult = await executeCoreFileRead({ absolute_path: nbPath }, {
+        readNotebook: async (p) => {
+            const parsed = JSON.parse(readFileSync(p, 'utf8'));
+            return Array.isArray(parsed.cells) ? parsed.cells : [];
+        },
+    });
+    assert.equal(coreResult.success, true, 'core read success');
+    assert.ok(coreResult.data, 'core data exists');
+    const data = coreResult.data;
+    assert.equal(data.type, 'notebook');
+    assert.equal(data.file.cells.length, 2);
+    // 3) Las celulas son identicas (deep equal)
+    assert.deepEqual(data.file.cells, direct, 'core path produces identical cells to direct readNotebook');
+}
+finally {
+    rmSync(tmp, { recursive: true, force: true });
+}
+console.log('notebook-parity smoke PASS');

package/dist/src/core/tools/registry.js

@@ -0,0 +1,22 @@
+import { coreFileReadTool } from './filesCore.js';
+import { coreGitTool } from './gitCore.js';
+import { corePowerShellTool, coreShellTool } from './shellCore.js';
+class Registry {
+    tools = new Map();
+    constructor() {
+        this.registerTool(coreFileReadTool);
+        this.registerTool(coreShellTool);
+        this.registerTool(corePowerShellTool);
+        this.registerTool(coreGitTool);
+    }
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    listTools() {
+        return Array.from(this.tools.values());
+    }
+}
+export const coreToolsRegistry = new Registry();

package/dist/src/core/tools/runtime.smoke.js

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { coreToolsRegistry } from './registry.js';
+const tempDir = await mkdtemp(join(tmpdir(), 'core-tools-smoke-'));
+try {
+    const fixture = join(tempDir, 'sample.txt');
+    await writeFile(fixture, ['alpha', 'beta', 'gamma'].join('\n'), 'utf8');
+    const readTool = coreToolsRegistry.getTool('Read');
+    assert.ok(readTool);
+    const readResult = await readTool.execute({ absolute_path: fixture, offset: 2, limit: 1 }, {});
+    assert.equal(readResult.success, true);
+    assert.equal(readResult.output, 'beta');
+    const shellTool = coreToolsRegistry.getTool(process.platform === 'win32' ? 'PowerShell' : 'Bash');
+    assert.ok(shellTool);
+    const shellResult = await shellTool.execute({
+        command: process.platform === 'win32'
+            ? 'Write-Output core-tools-smoke'
+            : 'printf core-tools-smoke',
+    }, {});
+    assert.equal(shellResult.success, true);
+    assert.match(shellResult.output ?? '', /core-tools-smoke/);
+    const gitTool = coreToolsRegistry.getTool('Git');
+    assert.ok(gitTool);
+    const gitResult = await gitTool.execute({ command: 'git status --short' }, { cwd: process.cwd() });
+    assert.equal(gitResult.success, true);
+    console.log('tools.runtime.smoke PASS');
+}
+finally {
+    await rm(tempDir, { recursive: true, force: true });
+}

package/dist/src/core/tools/shellCore.js

@@ -0,0 +1,60 @@
+import { exec } from '../../utils/Shell.js';
+function normalizeShellType(shellType) {
+    return shellType === 'powershell' ? 'powershell' : 'bash';
+}
+export async function startCoreShellCommand(input, context = {}) {
+    const command = input.command;
+    if (!command) {
+        throw new Error('command is required');
+    }
+    if (context.startShellCommand) {
+        return context.startShellCommand({
+            ...input,
+            shellType: normalizeShellType(input.shellType),
+        });
+    }
+    const controller = new AbortController();
+    if (context.abortSignal) {
+        const relayAbort = () => controller.abort(context.abortSignal?.reason);
+        if (context.abortSignal.aborted) {
+            relayAbort();
+        }
+        else {
+            context.abortSignal.addEventListener('abort', relayAbort, { once: true });
+        }
+    }
+    return exec(command, controller.signal, normalizeShellType(input.shellType), {
+        timeout: input.timeoutMs,
+        ...input.execOptions,
+    });
+}
+export async function executeCoreShellCommand(input, context = {}) {
+    try {
+        const shellCommand = await startCoreShellCommand(input, context);
+        const result = await shellCommand.result;
+        return formatCoreShellResult(result);
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+function formatCoreShellResult(result) {
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+    const isSuccess = result.code === 0 && !result.interrupted && !result.preSpawnError;
+    return {
+        success: isSuccess,
+        output: output || 'Command executed successfully with no output.',
+        error: isSuccess || !result.stderr ? undefined : result.stderr,
+        data: result,
+    };
+}
+export const coreShellTool = {
+    name: 'Bash',
+    description: 'Executes a shell command through the shared core runtime.',
+    execute: (input, context) => executeCoreShellCommand({ ...input, shellType: 'bash' }, context),
+};
+export const corePowerShellTool = {
+    name: 'PowerShell',
+    description: 'Executes a PowerShell command through the shared core runtime.',
+    execute: (input, context) => executeCoreShellCommand({ ...input, shellType: 'powershell' }, context),
+};

package/dist/src/core/types/agentContext.js

@@ -0,0 +1,9 @@
+// Tipos canonicos del core para AgentContext.
+//
+// Antes vivian en `utils/agentContext.ts`. Movidos aca para invertir la
+// dependencia: el core es ahora el dueno del contrato; el adapter (utils)
+// re-exporta para mantener compat de imports.
+//
+// Estos tipos son puros (no tienen dependencias del CLI). Se pueden usar
+// desde el Desktop o cualquier otro embedder sin arrastrar Ink/REPL.
+export {};

package/dist/src/core/types/auth.js

@@ -0,0 +1,3 @@
+// Pure auth types — no runtime dependencies on CLI utilities.
+// Owned by core. Used by loginCore.ts and logoutCore.ts.
+export {};

package/dist/src/core/types/command.js

@@ -0,0 +1,13 @@
+// Pure command types — no runtime dependencies on CLI utilities.
+// CLI-specific references (HookSettings, ToolUseContext, etc.) are
+// simplified to `unknown` so this file is self-contained and embeddable.
+/** Resolves the user-visible name, falling back to `cmd.name` when not overridden. */
+export function getCommandName(cmd) {
+    if (!cmd)
+        return '';
+    return cmd.userFacingName?.() ?? cmd.name ?? '';
+}
+/** Resolves whether the command is enabled, defaulting to true. */
+export function isCommandEnabled(cmd) {
+    return cmd.isEnabled?.() ?? true;
+}

package/dist/src/core/types/provider.js

@@ -0,0 +1,3 @@
+// Pure provider types - no runtime dependencies on CLI utilities.
+// These are owned by core and can be used anywhere in the system.
+export {};

package/dist/src/core/types/sdkEvent.js

@@ -0,0 +1,10 @@
+// Tipos canonicos del core para SdkEvent.
+//
+// Antes vivian en `utils/sdkEventQueue.ts`. Movidos aca para invertir la
+// dependencia: el core es ahora dueno del contrato; el adapter (utils)
+// re-exporta para mantener compat de imports.
+//
+// `SdkWorkflowProgress` queda como tipo opaco (`unknown[]`) para no acoplar
+// el core con el shape interno del CLI. El adapter puede tipar con mas
+// detalle al consumir.
+export {};

package/dist/src/core/types/swarm.js

@@ -0,0 +1 @@
+export {};

package/dist/src/cost-tracker.js

@@ -144,9 +144,9 @@ export function formatTotalCost() {
             : '');
     const modelUsageDisplay = formatModelUsage();
     return chalk.dim(`Costo total:           ${costDisplay}\n` +
-        `Duración total (API):  ${formatDuration(getTotalAPIDuration())}
-Duración total (reloj): ${formatDuration(getTotalDuration())}
-Total cambios código:  ${getTotalLinesAdded()} ${getTotalLinesAdded() === 1 ? 'línea' : 'líneas'} agregadas, ${getTotalLinesRemoved()} ${getTotalLinesRemoved() === 1 ? 'línea' : 'líneas'} eliminadas
+        `Duración total (API):  ${formatDuration(getTotalAPIDuration())}
+Duración total (reloj): ${formatDuration(getTotalDuration())}
+Total cambios código:  ${getTotalLinesAdded()} ${getTotalLinesAdded() === 1 ? 'línea' : 'líneas'} agregadas, ${getTotalLinesRemoved()} ${getTotalLinesRemoved() === 1 ? 'línea' : 'líneas'} eliminadas
 ${modelUsageDisplay}`);
 }
 function round(number, precision) {