@ikarmic/forge-core 4.4.0 → 5.0.0

package/dist/attachments.d.ts

@@ -0,0 +1,46 @@
+import type { FilePart, TextPart } from 'ai';
+export interface Attachment {
+    /** Display name, usually the file's base name. */
+    name: string;
+    /** IANA media type, e.g. `image/png`, `application/pdf`, `text/plain`. */
+    mediaType: string;
+    /** Base64 of the file's bytes (no `data:` prefix). */
+    data: string;
+}
+/** Same cap as read_image: what vision APIs accept without resampling. */
+export declare const MAX_IMAGE_ATTACHMENT_BYTES: number;
+/** PDF APIs accept around 32 MB; stay well inside it. */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** Text attachments past this are cut, with a note, so one log file can't fill the window. */
+export declare const MAX_TEXT_ATTACHMENT_CHARS = 200000;
+export type AttachmentKind = 'image' | 'pdf' | 'text' | 'binary';
+export declare function attachmentKind(mediaType: string): AttachmentKind;
+export declare function isPdf(buf: Uint8Array): boolean;
+/** True when the first 8 KB have no NUL byte and decode as UTF-8. */
+export declare function looksLikeText(buf: Uint8Array): boolean;
+/**
+ * Media type from the bytes: images and PDFs by their magic numbers, then text. The
+ * declared type (a browser's or an extension's guess) only names text and other
+ * binaries, so a mislabelled file is never sent to a provider as an image or PDF.
+ */
+export declare function detectMediaType(buf: Uint8Array, declared?: string): string;
+/** Why these bytes can't be attached, or null when they can. */
+export declare function attachmentProblem(bytes: number, mediaType: string): string | null;
+/** Build an attachment from raw bytes; throws with a readable reason when it can't be attached. */
+export declare function makeAttachment(name: string, bytes: Uint8Array, declaredType?: string): Attachment;
+/** Read a file from disk as an attachment. */
+export declare function loadAttachment(filePath: string): Promise<Attachment>;
+/** Decoded size of an attachment's data. */
+export declare function attachmentBytes(a: Attachment): number;
+export declare function formatBytes(n: number): string;
+/** One-line description, e.g. `screenshot.png (image/png, 120.4 KB)`. */
+export declare function describeAttachment(a: Attachment): string;
+/** The content parts that carry the attachments in a user message. */
+export declare function attachmentParts(attachments: readonly Attachment[]): Array<TextPart | FilePart>;
+/**
+ * Rough token cost of a non-text content part (an image is about 1,600 tokens on
+ * the major providers; a PDF page about the same, and PDFs run ~50 KB a page).
+ */
+export declare function mediaPartTokens(part: unknown): number;
+/** A short stand-in for a media part in transcripts (summaries, logs), never the bytes. */
+export declare function mediaPartLabel(part: unknown): string | null;

package/dist/attachments.js

@@ -0,0 +1,178 @@
+/**
+ * Files the user attaches to a chat turn (pasted screenshots, dropped PDFs, any other file).
+ *
+ * They travel in the turn's user message as native content parts, so vision and
+ * document-capable models see the real bytes instead of a read_image round trip:
+ *   - images (PNG / JPEG / GIF / WebP) and PDFs become `file` parts;
+ *   - text files are inlined as a fenced block;
+ *   - any other binary is described in one line (name, type, size) so the model knows it exists.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { sniffMime } from './tools/read-image.js';
+/** Same cap as read_image: what vision APIs accept without resampling. */
+export const MAX_IMAGE_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+/** PDF APIs accept around 32 MB; stay well inside it. */
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+/** Text attachments past this are cut, with a note, so one log file can't fill the window. */
+export const MAX_TEXT_ATTACHMENT_CHARS = 200_000;
+const IMAGE_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+export function attachmentKind(mediaType) {
+    if (IMAGE_TYPES.has(mediaType))
+        return 'image';
+    if (mediaType === 'application/pdf')
+        return 'pdf';
+    if (mediaType.startsWith('text/') || TEXTUAL_TYPES.has(mediaType))
+        return 'text';
+    return 'binary';
+}
+const TEXTUAL_TYPES = new Set([
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/x-yaml',
+    'application/yaml',
+    'application/toml',
+    'application/sql',
+    'image/svg+xml',
+]);
+export function isPdf(buf) {
+    return buf.length >= 5 && buf[0] === 0x25 && buf[1] === 0x50 && buf[2] === 0x44 && buf[3] === 0x46 && buf[4] === 0x2d;
+}
+/** True when the first 8 KB have no NUL byte and decode as UTF-8. */
+export function looksLikeText(buf) {
+    const sample = buf.subarray(0, Math.min(buf.length, 8192));
+    if (sample.includes(0))
+        return false;
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(sample);
+        return true;
+    }
+    catch {
+        // A multi-byte character cut at the 8 KB boundary is still text.
+        return sample.length === 8192 && looksLikeText(sample.subarray(0, 8188));
+    }
+}
+/**
+ * Media type from the bytes: images and PDFs by their magic numbers, then text. The
+ * declared type (a browser's or an extension's guess) only names text and other
+ * binaries, so a mislabelled file is never sent to a provider as an image or PDF.
+ */
+export function detectMediaType(buf, declared) {
+    // An empty name turns off sniffMime's extension fallback.
+    const image = sniffMime(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength), '');
+    if (image)
+        return image;
+    if (isPdf(buf))
+        return 'application/pdf';
+    const declaredKind = declared ? attachmentKind(declared) : 'binary';
+    if (looksLikeText(buf))
+        return declared && declaredKind === 'text' ? declared : 'text/plain';
+    return declared && declaredKind === 'binary' ? declared : 'application/octet-stream';
+}
+/** Why these bytes can't be attached, or null when they can. */
+export function attachmentProblem(bytes, mediaType) {
+    if (bytes === 0)
+        return 'the file is empty';
+    if (attachmentKind(mediaType) === 'image' && bytes > MAX_IMAGE_ATTACHMENT_BYTES) {
+        return `images are limited to ${MAX_IMAGE_ATTACHMENT_BYTES / 1024 / 1024} MB`;
+    }
+    if (bytes > MAX_ATTACHMENT_BYTES)
+        return `attachments are limited to ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`;
+    return null;
+}
+/** Build an attachment from raw bytes; throws with a readable reason when it can't be attached. */
+export function makeAttachment(name, bytes, declaredType) {
+    const mediaType = detectMediaType(bytes, declaredType);
+    const problem = attachmentProblem(bytes.length, mediaType);
+    if (problem)
+        throw new Error(`Cannot attach ${name}: ${problem}`);
+    return { name, mediaType, data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64') };
+}
+/** Read a file from disk as an attachment. */
+export async function loadAttachment(filePath) {
+    const name = path.basename(filePath);
+    const info = await stat(filePath);
+    if (info.isDirectory())
+        throw new Error(`Cannot attach ${name}: it is a directory`);
+    // Check the size before reading so a 2 GB file isn't pulled into memory.
+    if (info.size > MAX_ATTACHMENT_BYTES)
+        throw new Error(`Cannot attach ${name}: attachments are limited to ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`);
+    return makeAttachment(name, await readFile(filePath));
+}
+/** Decoded size of an attachment's data. */
+export function attachmentBytes(a) {
+    const pad = a.data.endsWith('==') ? 2 : a.data.endsWith('=') ? 1 : 0;
+    return Math.floor((a.data.length * 3) / 4) - pad;
+}
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+/** One-line description, e.g. `screenshot.png (image/png, 120.4 KB)`. */
+export function describeAttachment(a) {
+    return `${a.name} (${a.mediaType}, ${formatBytes(attachmentBytes(a))})`;
+}
+/** The content parts that carry the attachments in a user message. */
+export function attachmentParts(attachments) {
+    const parts = [];
+    for (const a of attachments) {
+        const kind = attachmentKind(a.mediaType);
+        if (kind === 'image' || kind === 'pdf') {
+            parts.push({ type: 'text', text: `Attached file: ${describeAttachment(a)}` });
+            parts.push({ type: 'file', mediaType: a.mediaType, filename: a.name, data: { type: 'data', data: a.data } });
+        }
+        else if (kind === 'text') {
+            let text = Buffer.from(a.data, 'base64').toString('utf8');
+            let note = '';
+            if (text.length > MAX_TEXT_ATTACHMENT_CHARS) {
+                note = `\n[cut at ${MAX_TEXT_ATTACHMENT_CHARS} of ${text.length} characters]`;
+                text = text.slice(0, MAX_TEXT_ATTACHMENT_CHARS);
+            }
+            const fence = text.includes('```') ? '~~~~' : '```';
+            parts.push({ type: 'text', text: `Attached file: ${a.name}\n${fence}\n${text}\n${fence}${note}` });
+        }
+        else {
+            parts.push({
+                type: 'text',
+                text: `Attached file: ${describeAttachment(a)}. It is binary and can't be shown; ask the user what they need from it.`,
+            });
+        }
+    }
+    return parts;
+}
+/**
+ * Rough token cost of a non-text content part (an image is about 1,600 tokens on
+ * the major providers; a PDF page about the same, and PDFs run ~50 KB a page).
+ */
+export function mediaPartTokens(part) {
+    if (!part || typeof part !== 'object')
+        return 0;
+    const p = part;
+    if (p.type === 'image' || p.type === 'image-data')
+        return 1600;
+    if (p.type !== 'file' && p.type !== 'file-data')
+        return 0;
+    const mediaType = typeof p.mediaType === 'string' ? p.mediaType : '';
+    if (mediaType.startsWith('image'))
+        return 1600;
+    const raw = p.data && typeof p.data === 'object' && 'data' in p.data ? p.data.data : p.data;
+    const len = typeof raw === 'string' ? raw.length : raw instanceof Uint8Array ? (raw.length * 4) / 3 : 0;
+    return Math.max(1600, Math.ceil(((len * 3) / 4 / 50_000) * 1600));
+}
+/** A short stand-in for a media part in transcripts (summaries, logs), never the bytes. */
+export function mediaPartLabel(part) {
+    if (!part || typeof part !== 'object')
+        return null;
+    const p = part;
+    if (p.type === 'image' || p.type === 'image-data')
+        return '[image]';
+    if (p.type === 'file' || p.type === 'file-data') {
+        const name = typeof p.filename === 'string' ? `${p.filename}, ` : '';
+        return `[attached file: ${name}${typeof p.mediaType === 'string' ? p.mediaType : 'unknown type'}]`;
+    }
+    return null;
+}

package/dist/browser/cdp.d.ts

@@ -29,4 +29,3 @@ export declare class CdpClient {
 /** Open a CDP connection to `wsUrl` using the runtime's global WebSocket. */
 export declare function connectWebSocket(wsUrl: string, timeoutMs?: number): Promise<CdpTransport>;
 export {};
-//# sourceMappingURL=cdp.d.ts.map

package/dist/browser/cdp.js

@@ -123,4 +123,3 @@ export function connectWebSocket(wsUrl, timeoutMs = 10_000) {
         });
     });
 }
-//# sourceMappingURL=cdp.js.map

package/dist/browser/chrome.d.ts

@@ -11,4 +11,3 @@ export declare function launchChrome(chromePath: string, options?: {
     headless?: boolean;
     timeoutMs?: number;
 }): Promise<LaunchedBrowser>;
-//# sourceMappingURL=chrome.d.ts.map

package/dist/browser/chrome.js

@@ -100,4 +100,3 @@ export async function launchChrome(chromePath, options = {}) {
     });
     return { port, kill: cleanup };
 }
-//# sourceMappingURL=chrome.js.map

package/dist/browser/session.d.ts

@@ -54,4 +54,3 @@ export declare class BrowserSession {
     get isOpen(): boolean;
     close(): Promise<void>;
 }
-//# sourceMappingURL=session.d.ts.map

package/dist/browser/session.js

@@ -156,4 +156,3 @@ export class BrowserSession {
         this.console = [];
     }
 }
-//# sourceMappingURL=session.js.map

package/dist/checkpoints/index.d.ts

@@ -9,4 +9,3 @@
  */
 export { CheckpointStore, type CheckpointStoreLimits } from './store.js';
 export type { CaptureOptions, Checkpoint, CheckpointFile, CheckpointFileStatus, CheckpointSummary, CheckpointTrigger, PruneResult, RestoreResult, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/checkpoints/index.js

@@ -8,4 +8,3 @@
  * surfaces list/show/restore/prune via `forge checkpoint …`.
  */
 export { CheckpointStore } from './store.js';
-//# sourceMappingURL=index.js.map

package/dist/checkpoints/store.d.ts

@@ -86,4 +86,3 @@ export declare class CheckpointStore {
     /** Delete every checkpoint for this session. Called on session reset. */
     clear(): Promise<void>;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/checkpoints/store.js

@@ -408,4 +408,3 @@ function defaultDescription(options) {
     }
     return 'manual checkpoint';
 }
-//# sourceMappingURL=store.js.map

package/dist/checkpoints/types.d.ts

@@ -159,4 +159,3 @@ export interface CaptureOptions {
      */
     worktreeContextOverride?: import('./types.js').CheckpointWorktreeContext | null;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/checkpoints/types.js

@@ -18,4 +18,3 @@
  * checkpoints travel with sessions when they're saved / resumed.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/code-index/builder.d.ts

@@ -6,4 +6,3 @@ import type { IndexManifest } from './types.js';
  * (only when something actually changed): never once per file.
  */
 export declare function ensureFresh(cwd: string): Promise<IndexManifest>;
-//# sourceMappingURL=builder.d.ts.map

package/dist/code-index/builder.js

@@ -1,5 +1,6 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { IgnoreRules } from '../tools/ignore-rules.js';
 import { DEFAULT_IGNORED_DIRS } from '../tools/shared.js';
 import { deleteEntry, getEntry, loadManifest, saveManifest, setEntry } from './index-store.js';
 import { parseSource } from './parser.js';
@@ -14,6 +15,7 @@ export async function ensureFresh(cwd) {
     const manifest = await loadManifest(cwd);
     const seen = new Set();
     let changed = false;
+    const rules = IgnoreRules.forRoot(cwd);
     async function walk(dir) {
         let entries;
         try {
@@ -28,6 +30,8 @@ export async function ensureFresh(cwd) {
             if (DEFAULT_IGNORED_DIRS.has(entry.name))
                 continue;
             const abs = path.join(dir, entry.name);
+            if (rules.isIgnored(abs, entry.isDirectory()))
+                continue;
             if (entry.isDirectory()) {
                 await walk(abs);
                 continue;
@@ -60,4 +64,3 @@ export async function ensureFresh(cwd) {
         await saveManifest(cwd, manifest);
     return manifest;
 }
-//# sourceMappingURL=builder.js.map

package/dist/code-index/index-store.d.ts

@@ -9,4 +9,3 @@ export declare function saveManifest(cwd: string, manifest: IndexManifest): Prom
 export declare function getEntry(manifest: IndexManifest, relPath: string): IndexFileEntry | undefined;
 export declare function setEntry(manifest: IndexManifest, relPath: string, entry: IndexFileEntry): void;
 export declare function deleteEntry(manifest: IndexManifest, relPath: string): void;
-//# sourceMappingURL=index-store.d.ts.map

package/dist/code-index/index-store.js

@@ -41,4 +41,3 @@ function isValidManifest(value) {
     const v = value;
     return v.version === 1 && typeof v.files === 'object' && v.files !== null;
 }
-//# sourceMappingURL=index-store.js.map

package/dist/code-index/parser.d.ts

@@ -19,4 +19,3 @@ export interface SyntaxProblem {
  * and an empty array when the file parses cleanly.
  */
 export declare function findSyntaxErrors(source: string, ext: string): Promise<SyntaxProblem[] | null>;
-//# sourceMappingURL=parser.d.ts.map

package/dist/code-index/parser.js

@@ -286,4 +286,3 @@ function unwrapExport(node) {
     const inner = node.namedChildren.find((c) => c && c.type !== 'export_clause' && c.type !== 'string');
     return inner ?? node;
 }
-//# sourceMappingURL=parser.js.map

package/dist/code-index/types.d.ts

@@ -21,4 +21,3 @@ export interface IndexManifest {
     version: 1;
     files: Record<string, IndexFileEntry>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/code-index/types.js

@@ -3,4 +3,3 @@
  * list_symbols, find_references) and the index that backs them.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/commands/custom-commands.d.ts

@@ -0,0 +1,24 @@
+export interface CustomCommand {
+    /** Lowercase name used after the slash. */
+    name: string;
+    description?: string;
+    template: string;
+    source: 'user' | 'project';
+    /** Absolute path of the template file. */
+    file: string;
+}
+export declare function commandDirs(cwd: string, home?: string): Array<{
+    dir: string;
+    source: 'user' | 'project';
+}>;
+/** Split optional `---` front matter from the body and read its `description`. */
+export declare function parseCommandFile(text: string): {
+    description?: string;
+    template: string;
+};
+/** Every custom command, keyed by name; project commands replace personal ones. */
+export declare function loadCustomCommands(cwd: string, home?: string): Promise<Map<string, CustomCommand>>;
+/** The message a command sends for these arguments. */
+export declare function expandCustomCommand(command: Pick<CustomCommand, 'template'>, args: string): string;
+/** `/name — description` lines for help output. */
+export declare function formatCustomCommands(commands: Map<string, CustomCommand>): string;

package/dist/commands/custom-commands.js

@@ -0,0 +1,98 @@
+/**
+ * Custom slash commands: Markdown prompt templates the user keeps in
+ * `~/.forge/commands/<name>.md` (personal) or `<project>/.forge/commands/<name>.md`
+ * (shared with the repo; a project command overrides a personal one of the same name).
+ *
+ * `/<name> some args` sends the file's body as the message, with `$ARGUMENTS` replaced by
+ * everything after the name and `$1`..`$9` by its words (quotes group words). A template
+ * without `$ARGUMENTS` gets the arguments appended. An optional front matter block
+ * gives a `description` for /help:
+ *
+ *   ---
+ *   description: Review the staged diff for bugs
+ *   ---
+ *   Review `git diff --staged` ... $ARGUMENTS
+ *
+ * Templates are only text the user could have typed: nothing in them runs by itself.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/** Names are what parseSlashCommand accepts: a letter, then letters, digits, `-` or `_`. */
+const NAME = /^[a-z][\w-]*$/;
+/** A template larger than this is skipped: it's a prompt, not a document. */
+const MAX_TEMPLATE_BYTES = 64 * 1024;
+export function commandDirs(cwd, home = os.homedir()) {
+    return [
+        { dir: path.join(home, '.forge', 'commands'), source: 'user' },
+        { dir: path.join(cwd, '.forge', 'commands'), source: 'project' },
+    ];
+}
+/** Split optional `---` front matter from the body and read its `description`. */
+export function parseCommandFile(text) {
+    const normalized = text.replace(/^/, '').replace(/\r\n/g, '\n');
+    const m = /^---\n([\s\S]*?)\n---\n?/.exec(normalized);
+    if (!m)
+        return { template: normalized.trim() };
+    const desc = /^description:\s*(.+)$/m.exec(m[1])?.[1]?.trim().replace(/^(['"])(.*)\1$/, '$2');
+    return { ...(desc ? { description: desc } : {}), template: normalized.slice(m[0].length).trim() };
+}
+/** Every custom command, keyed by name; project commands replace personal ones. */
+export async function loadCustomCommands(cwd, home) {
+    const out = new Map();
+    for (const { dir, source } of commandDirs(cwd, home)) {
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files.sort()) {
+            if (!f.toLowerCase().endsWith('.md'))
+                continue;
+            const name = f.slice(0, -3).toLowerCase();
+            if (!NAME.test(name))
+                continue;
+            const file = path.join(dir, f);
+            let text;
+            try {
+                const buf = await readFile(file);
+                if (buf.length > MAX_TEMPLATE_BYTES)
+                    continue;
+                text = buf.toString('utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = parseCommandFile(text);
+            if (!parsed.template)
+                continue;
+            out.set(name, { name, ...parsed, source, file });
+        }
+    }
+    return out;
+}
+function words(args) {
+    const out = [];
+    for (const m of args.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g))
+        out.push(m[1] ?? m[2] ?? m[3]);
+    return out;
+}
+/** The message a command sends for these arguments. */
+export function expandCustomCommand(command, args) {
+    const trimmed = args.trim();
+    const positional = words(trimmed);
+    const usesArguments = command.template.includes('$ARGUMENTS');
+    const usesPositional = /\$[1-9]/.test(command.template);
+    // One pass, so an argument that itself contains `$1` or `$ARGUMENTS` is left alone.
+    const body = command.template.replace(/\$ARGUMENTS|\$([1-9])/g, (_m, n) => n ? (positional[Number(n) - 1] ?? '') : trimmed);
+    return !usesArguments && !usesPositional && trimmed ? `${body}\n\n${trimmed}` : body;
+}
+/** `/name — description` lines for help output. */
+export function formatCustomCommands(commands) {
+    return [...commands.values()]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((c) => `/${c.name}${c.description ? ` — ${c.description}` : ''}${c.source === 'project' ? ' (project)' : ''}`)
+        .join('\n');
+}

package/dist/config-file.d.ts

@@ -22,6 +22,10 @@ export interface ForgeConfigFile {
     }>>;
     /** Short names for models: `"fast": "anthropic:claude-haiku-4-5"`. See model-alias.ts. */
     aliases?: ModelAliases;
+    /** Model for a chat mode that has none of its own: mode id → `provider:model`, bare model id or alias. */
+    modeModels?: Record<string, string>;
+    /** Delete saved sessions not updated for this many days, when the VS Code extension starts. Unset keeps everything. */
+    sessionRetentionDays?: number;
     display?: {
         blockDefault?: 'collapsed' | 'expanded';
         detail?: 'compact' | 'full';
@@ -41,4 +45,3 @@ export declare function loadForgeConfigFile(configPath?: string): Promise<LoadFo
  * Fields not present in `partial` are left untouched.
  */
 export declare function saveForgeConfigFile(partial: ForgeConfigFile, configPath?: string): Promise<void>;
-//# sourceMappingURL=config-file.d.ts.map

package/dist/config-file.js

@@ -57,4 +57,3 @@ export async function saveForgeConfigFile(partial, configPath) {
     await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
 }
-//# sourceMappingURL=config-file.js.map

package/dist/config.d.ts

@@ -36,4 +36,3 @@ export declare function resolveApiKey(provider: ProviderName, opts: {
     legacySetting?: string;
     env?: NodeJS.ProcessEnv;
 }): Promise<string | undefined>;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -189,4 +189,3 @@ function assertSupportedProvider(cfg) {
     }
     return cfg;
 }
-//# sourceMappingURL=config.js.map

package/dist/context/compaction.d.ts

@@ -82,4 +82,3 @@ export interface CompactionResult {
 export declare function compactMessages(allMessages: ModelMessage[], summarizer: Summarizer, options?: {
     keepRecent?: number;
 }): Promise<CompactionResult>;
-//# sourceMappingURL=compaction.d.ts.map

package/dist/context/compaction.js

@@ -12,6 +12,8 @@
  * dedicated cheaper model or even a deterministic extractive summarizer.
  */
 import { generateText } from 'ai';
+import { mediaPartLabel, mediaPartTokens } from '../attachments.js';
+import { stripThinkTags } from '../agent/think-tags.js';
 import { createLanguageModel } from '../providers.js';
 /**
  * Approximate model context window (input) in tokens. Used to decide when
@@ -95,6 +97,12 @@ export function getModelWindowTokens(model) {
     }
     return DEFAULT_WINDOW_TOKENS;
 }
+/** JSON.stringify replacer that keeps image and file bytes out of a summary prompt. */
+function withoutMedia(_key, value) {
+    if (typeof value === 'string' && value.startsWith('data:') && value.length > 200)
+        return '[media bytes]';
+    return mediaPartLabel(value) ?? value;
+}
 /** Approximate token count from a string. Rough: ~4 chars/token. */
 export function estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -113,6 +121,9 @@ export function estimateMessageTokens(messages) {
                 if (part && typeof part === 'object' && 'text' in part) {
                     total += estimateTokens(String(part.text ?? ''));
                 }
+                else {
+                    total += mediaPartTokens(part);
+                }
             }
         }
     }
@@ -141,7 +152,7 @@ export function buildLlmSummarizer(model, modelFactory) {
                         return p;
                     if (p && typeof p === 'object' && 'text' in p)
                         return String(p.text);
-                    return JSON.stringify(p);
+                    return mediaPartLabel(p) ?? JSON.stringify(p, withoutMedia);
                 })
                     .join('\n');
             }
@@ -191,7 +202,8 @@ ${truncateToBudget(transcript, 60_000)}`;
             prompt,
             maxOutputTokens: 2000,
         });
-        return result.text.trim();
+        // Reasoning models put an inline <think> block in the reply; it must not be stored as the summary.
+        return stripThinkTags(result.text).trim();
     };
 }
 /** Truncate the transcript at a character budget so we don't blow the summarizer's own context. */
@@ -249,6 +261,9 @@ export async function compactMessages(allMessages, summarizer, options = {}) {
     const pinned = toSummarize[0]?.role === 'user' ? toSummarize[0] : undefined;
     const beforeTokens = estimateMessageTokens(toSummarize) - (pinned ? estimateMessageTokens([pinned]) : 0);
     const summary = await summarizer(toSummarize);
+    // An empty summary (a failed or reasoning-only reply) must not replace the dropped turns with nothing.
+    if (!summary.trim())
+        return { messages: allMessages, droppedCount: 0, savedTokens: 0, summary: '' };
     const summaryTokens = estimateTokens(summary);
     const separator = {
         role: 'system',
@@ -270,4 +285,3 @@ export async function compactMessages(allMessages, summarizer, options = {}) {
         summary,
     };
 }
-//# sourceMappingURL=compaction.js.map

package/dist/context/mask.d.ts

@@ -43,4 +43,3 @@ export interface StepMasker {
  * `keepRecentTurns` more turns have been added.
  */
 export declare function createStepMasker(opts: StepMaskerOptions): StepMasker;
-//# sourceMappingURL=mask.d.ts.map

package/dist/context/mask.js

@@ -1,5 +1,5 @@
 /** Results that say what a change did are kept: they are small and the model must not forget them. */
-export const NEVER_MASK_TOOLS = new Set(['write_file', 'edit_file', 'run_command', 'sub_agent']);
+export const NEVER_MASK_TOOLS = new Set(['write_file', 'edit_file', 'edit_notebook', 'run_command', 'sub_agent']);
 const STUB_MARK = 'result not shown to save context';
 /** Index of the first message of the last `keepRecentTurns` assistant turns (0 when there are not that many). */
 export function maskBoundary(messages, keepRecentTurns) {
@@ -76,4 +76,3 @@ export function createStepMasker(opts) {
         },
     };
 }
-//# sourceMappingURL=mask.js.map

package/dist/credentials/index.d.ts

@@ -4,4 +4,3 @@ export type { CredentialStore } from './types.js';
 export declare const CREDENTIAL_SERVICE_NAME = "ikarmic-forge";
 /** Account key for a provider's stored API key: same on every surface. */
 export declare function credentialAccountKey(provider: ProviderName): string;
-//# sourceMappingURL=index.d.ts.map

package/dist/credentials/index.js

@@ -4,4 +4,3 @@ export const CREDENTIAL_SERVICE_NAME = 'ikarmic-forge';
 export function credentialAccountKey(provider) {
     return `apiKey:${provider}`;
 }
-//# sourceMappingURL=index.js.map

package/dist/credentials/types.d.ts

@@ -11,4 +11,3 @@ export interface CredentialStore {
     set(provider: ProviderName, key: string): Promise<void>;
     delete(provider: ProviderName): Promise<void>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/credentials/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/diff/index.d.ts

@@ -5,4 +5,3 @@
  * extension's pending-changes review UI. No I/O, no platform deps.
  */
 export { computeUnifiedDiff, computeDiffSummary, type DiffOptions, type DiffResult, type DiffSummary, } from './unified-diff.js';
-//# sourceMappingURL=index.d.ts.map