careervivid 1.10.0 → 1.11.2

package/dist/agent/QueryEngine.d.ts

@@ -0,0 +1,64 @@
+import { GenerateContentResponse, Content } from '@google/genai';
+import { Tool } from './Tool.js';
+export declare const CODING_AGENT_SYSTEM_PROMPT: string;
+export interface QueryEngineOptions {
+    model?: string;
+    systemInstruction?: string;
+    tools?: Tool[];
+    apiKey?: string;
+    /** GCP project ID for Vertex AI mode (uses gcloud ADC, no API key needed). */
+    project?: string;
+    /** GCP region for Vertex AI. Default: us-central1 */
+    location?: string;
+    /** Max thinking tokens for Gemini 2.5+. Set to 0 to disable. Default: 8192 */
+    thinkingBudget?: number;
+    /** Show raw thinking text in onThinking hook. Default: false */
+    includeThoughts?: boolean;
+    /** Auto-compact history when it exceeds this many turns. Default: 40 */
+    maxHistoryLength?: number;
+}
+export interface IterationHook {
+    onStart?: () => void;
+    onResponse?: (response: GenerateContentResponse) => void;
+    onToolCall?: (toolName: string, args: any) => Promise<boolean | void>;
+    onToolResult?: (toolName: string, result: any) => void;
+    onError?: (error: Error) => void;
+    /** Fired for each text chunk in streaming mode */
+    onChunk?: (text: string) => void;
+    /** Fired when thinking tokens arrive (if includeThoughts is enabled) */
+    onThinking?: (thought: string) => void;
+    /** Fired when the context is being compacted */
+    onCompacting?: () => void;
+}
+/**
+ * The unified QueryEngine executing an autonomous REPL-like agentic loop
+ * using @google/genai. Supports streaming, thinking mode, automatic context
+ * compaction, and exponential-backoff retry.
+ */
+export declare class QueryEngine {
+    private ai;
+    private history;
+    private model;
+    private systemInstruction;
+    private tools;
+    private toolMap;
+    private thinkingBudget;
+    private includeThoughts;
+    private maxHistoryLength;
+    constructor(options?: QueryEngineOptions);
+    getHistory(): Content[];
+    setHistory(history: Content[]): void;
+    /** Add API keys / tools after construction */
+    addTools(tools: Tool[]): void;
+    private buildGenerateConfig;
+    private maybeCompact;
+    private executeToolCalls;
+    runLoop(prompt: string, hooks?: IterationHook): Promise<string>;
+    /**
+     * Like runLoop() but streams text chunks via hooks.onChunk().
+     * Tool-call iterations are still non-streaming (we need the full response
+     * to extract functionCalls reliably).
+     */
+    runLoopStreaming(prompt: string, hooks?: IterationHook): Promise<string>;
+}
+//# sourceMappingURL=QueryEngine.d.ts.map

package/dist/agent/QueryEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryEngine.d.ts","sourceRoot":"","sources":["../../src/agent/QueryEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,uBAAuB,EAAE,OAAO,EAAQ,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,IAAI,EAAsB,MAAM,WAAW,CAAC;AAMrD,eAAO,MAAM,0BAA0B,QA8B/B,CAAC;AAMT,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IACzD,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IACtE,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACvD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,kDAAkD;IAClD,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,wEAAwE;IACxE,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAyCD;;;;GAIG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAAc;IACxB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,gBAAgB,CAAS;gBAErB,OAAO,GAAE,kBAAuB;IAyBrC,UAAU,IAAI,OAAO,EAAE;IAIvB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE;IAIpC,8CAA8C;IACvC,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE;IAW7B,OAAO,CAAC,mBAAmB;YAcb,YAAY;YAOZ,gBAAgB;IA6DjB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA8E5E;;;;OAIG;IACU,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;CA2EtF"}

package/dist/agent/QueryEngine.js

@@ -0,0 +1,330 @@
+import { GoogleGenAI } from '@google/genai';
+import { convertToGenAITool } from './Tool.js';
+import { compactHistory } from './contextCompaction.js';
+// ---------------------------------------------------------------------------
+// Elite Coding System Prompt
+// ---------------------------------------------------------------------------
+export const CODING_AGENT_SYSTEM_PROMPT = `
+You are an expert autonomous coding agent running inside the CareerVivid CLI.
+You have access to tools that let you read files, write files, search the codebase, and execute shell commands.
+
+## Core Rules
+
+1. **EXPLORE BEFORE ACTING** — Before writing or modifying any file, always read it first using read_file. Never overwrite a file blindly.
+2. **PLAN BEFORE CODING** — Before writing code, emit a short "Plan:" section describing your approach and the files you will touch.
+3. **MINIMAL FOOTPRINT** — Make the smallest change that correctly solves the problem. Prefer patch_file over rewriting entire files.
+4. **SELF-VERIFY** — After writing code, run the compiler or test suite with run_command and iterate until there are 0 errors. Never claim "done" without verifying.
+5. **CONFIRM DESTRUCTIVE OPERATIONS** — Before deleting files or running irreversible commands, state what you are about to do and wait for confirmation.
+6. **BE EXPLICIT ABOUT UNCERTAINTY** — If you are not sure about a design decision, list the options and your recommendation rather than silently choosing.
+
+## Workflow Pattern
+
+For every coding task, follow this loop:
+1. Read relevant files to understand the existing code structure.
+2. Emit a short plan (file list, approach, risks).
+3. Write the code using write_file or patch_file.
+4. Verify with run_command (tsc --noEmit, npm test, etc.).
+5. Fix any errors and loop back to step 4 until clean.
+6. Summarize all changes made.
+
+## Code Quality Standards
+
+- Use TypeScript with strict types. Avoid 'any' unless unavoidable.
+- Follow the existing code style of the file being edited.
+- Add JSDoc comments to all public functions and interfaces.
+- Write self-documenting code — variable names should explain intent.
+- Keep functions short and focused on a single responsibility.
+`.trim();
+// ---------------------------------------------------------------------------
+// Retry utility
+// ---------------------------------------------------------------------------
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+function isRetryableError(e) {
+    // Google GenAI errors often have a status field
+    if (e?.status && RETRYABLE_STATUS_CODES.has(e.status))
+        return true;
+    if (e?.message && /rate.?limit|quota|too.?many.?requests|service.?unavailable/i.test(e.message))
+        return true;
+    return false;
+}
+async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function retryWithBackoff(fn, maxRetries = 3, baseDelayMs = 1000) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (attempt === maxRetries || !isRetryableError(e))
+                throw e;
+            const delay = baseDelayMs * Math.pow(2, attempt);
+            await sleep(delay);
+        }
+    }
+    // TypeScript requires this even though it's unreachable
+    throw new Error('retryWithBackoff: unreachable');
+}
+// ---------------------------------------------------------------------------
+// QueryEngine
+// ---------------------------------------------------------------------------
+/**
+ * The unified QueryEngine executing an autonomous REPL-like agentic loop
+ * using @google/genai. Supports streaming, thinking mode, automatic context
+ * compaction, and exponential-backoff retry.
+ */
+export class QueryEngine {
+    ai;
+    history = [];
+    model;
+    systemInstruction;
+    tools;
+    toolMap;
+    thinkingBudget;
+    includeThoughts;
+    maxHistoryLength;
+    constructor(options = {}) {
+        const apiKey = options.apiKey;
+        const project = options.project ?? process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCLOUD_PROJECT;
+        const location = options.location ?? process.env.GOOGLE_CLOUD_LOCATION ?? 'us-central1';
+        const useVertexAI = !apiKey && !!project;
+        if (useVertexAI) {
+            // Vertex AI mode — uses gcloud Application Default Credentials
+            this.ai = new GoogleGenAI({ vertexai: true, project, location });
+            // Vertex AI uses a different model namespace
+            this.model = options.model || 'gemini-2.5-flash-preview-04-17';
+        }
+        else {
+            // Gemini API mode — requires an API key
+            this.ai = new GoogleGenAI({ apiKey: apiKey || '' });
+            this.model = options.model || 'gemini-2.5-flash';
+        }
+        this.systemInstruction = options.systemInstruction || CODING_AGENT_SYSTEM_PROMPT;
+        this.tools = options.tools || [];
+        this.toolMap = new Map(this.tools.map(t => [t.name, t]));
+        this.thinkingBudget = options.thinkingBudget ?? 8192;
+        this.includeThoughts = options.includeThoughts ?? false;
+        this.maxHistoryLength = options.maxHistoryLength ?? 40;
+    }
+    getHistory() {
+        return this.history;
+    }
+    setHistory(history) {
+        this.history = history;
+    }
+    /** Add API keys / tools after construction */
+    addTools(tools) {
+        for (const t of tools) {
+            this.tools.push(t);
+            this.toolMap.set(t.name, t);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    buildGenerateConfig(genAITools) {
+        const config = {
+            systemInstruction: this.systemInstruction,
+        };
+        if (genAITools.length > 0)
+            config.tools = genAITools;
+        if (this.thinkingBudget > 0) {
+            config.thinkingConfig = {
+                thinkingBudget: this.thinkingBudget,
+                includeThoughts: this.includeThoughts,
+            };
+        }
+        return config;
+    }
+    async maybeCompact(hooks) {
+        if (this.history.length > this.maxHistoryLength) {
+            if (hooks?.onCompacting)
+                hooks.onCompacting();
+            this.history = await compactHistory(this.ai, this.history, this.model);
+        }
+    }
+    async executeToolCalls(functionCalls, hooks) {
+        const functionResponses = [];
+        for (const call of functionCalls) {
+            const toolName = call.name || '';
+            const args = call.args || {};
+            const tool = this.toolMap.get(toolName);
+            if (!tool) {
+                functionResponses.push({
+                    functionResponse: {
+                        name: toolName,
+                        response: { error: `Tool "${toolName}" not found. Available tools: ${[...this.toolMap.keys()].join(', ')}` },
+                    },
+                });
+                continue;
+            }
+            // Confirmation gate
+            if (hooks?.onToolCall) {
+                const allow = await hooks.onToolCall(toolName, args);
+                if (allow === false) {
+                    functionResponses.push({
+                        functionResponse: {
+                            name: toolName,
+                            response: { error: 'User denied tool execution.' },
+                        },
+                    });
+                    continue;
+                }
+            }
+            try {
+                const result = await tool.execute(args);
+                if (hooks?.onToolResult)
+                    hooks.onToolResult(toolName, result);
+                functionResponses.push({
+                    functionResponse: {
+                        name: toolName,
+                        response: { result },
+                    },
+                });
+            }
+            catch (err) {
+                functionResponses.push({
+                    functionResponse: {
+                        name: toolName,
+                        response: { error: String(err.message || err) },
+                    },
+                });
+            }
+        }
+        return functionResponses;
+    }
+    // -------------------------------------------------------------------------
+    // Non-streaming loop
+    // -------------------------------------------------------------------------
+    async runLoop(prompt, hooks) {
+        this.history.push({ role: 'user', parts: [{ text: prompt }] });
+        const genAITools = this.tools.map(convertToGenAITool);
+        const config = this.buildGenerateConfig(genAITools);
+        let maxIterations = 30;
+        let iterations = 0;
+        let finalAnswer = '';
+        while (iterations < maxIterations) {
+            iterations++;
+            if (hooks?.onStart)
+                hooks.onStart();
+            // Auto-compact before hitting the API
+            await this.maybeCompact(hooks);
+            try {
+                const response = await retryWithBackoff(() => this.ai.models.generateContent({
+                    model: this.model,
+                    contents: this.history,
+                    config: config,
+                }));
+                if (hooks?.onResponse)
+                    hooks.onResponse(response);
+                // Capture thinking text if included
+                if (this.includeThoughts && hooks?.onThinking) {
+                    const thoughtParts = response.candidates?.[0]?.content?.parts?.filter((p) => p.thought);
+                    for (const part of thoughtParts || []) {
+                        if (part.text)
+                            hooks.onThinking(part.text);
+                    }
+                }
+                // Separate tool calls from text parts
+                const functionCalls = response.functionCalls;
+                const hasToolCalls = functionCalls && functionCalls.length > 0;
+                // Add model response to history
+                this.history.push({
+                    role: 'model',
+                    parts: hasToolCalls
+                        ? functionCalls.map(fc => ({
+                            functionCall: { name: fc.name, args: fc.args },
+                        }))
+                        : [{ text: response.text || '' }],
+                });
+                if (!hasToolCalls) {
+                    finalAnswer = response.text || '';
+                    break;
+                }
+                const functionResponses = await this.executeToolCalls(functionCalls, hooks);
+                this.history.push({ role: 'user', parts: functionResponses });
+            }
+            catch (e) {
+                if (hooks?.onError)
+                    hooks.onError(e);
+                finalAnswer = `Generation Error: ${e.message}`;
+                break;
+            }
+        }
+        if (iterations >= maxIterations) {
+            finalAnswer = finalAnswer || 'Max iterations (30) exceeded without a final answer.';
+        }
+        return finalAnswer;
+    }
+    // -------------------------------------------------------------------------
+    // Streaming loop
+    // -------------------------------------------------------------------------
+    /**
+     * Like runLoop() but streams text chunks via hooks.onChunk().
+     * Tool-call iterations are still non-streaming (we need the full response
+     * to extract functionCalls reliably).
+     */
+    async runLoopStreaming(prompt, hooks) {
+        this.history.push({ role: 'user', parts: [{ text: prompt }] });
+        const genAITools = this.tools.map(convertToGenAITool);
+        const config = this.buildGenerateConfig(genAITools);
+        let maxIterations = 30;
+        let iterations = 0;
+        let finalAnswer = '';
+        while (iterations < maxIterations) {
+            iterations++;
+            if (hooks?.onStart)
+                hooks.onStart();
+            await this.maybeCompact(hooks);
+            try {
+                // Use streaming for final text responses; non-streaming for tool call turns
+                const streamResponse = await retryWithBackoff(() => this.ai.models.generateContentStream({
+                    model: this.model,
+                    contents: this.history,
+                    config: config,
+                }));
+                let accumulatedText = '';
+                let accumulatedFunctionCalls = [];
+                for await (const chunk of streamResponse) {
+                    // Text chunk
+                    const chunkText = chunk.text;
+                    if (chunkText) {
+                        accumulatedText += chunkText;
+                        if (hooks?.onChunk)
+                            hooks.onChunk(chunkText);
+                    }
+                    // Accumulate function calls
+                    if (chunk.functionCalls) {
+                        accumulatedFunctionCalls.push(...chunk.functionCalls);
+                    }
+                }
+                const hasToolCalls = accumulatedFunctionCalls.length > 0;
+                // Add model turn to history
+                this.history.push({
+                    role: 'model',
+                    parts: hasToolCalls
+                        ? accumulatedFunctionCalls.map(fc => ({
+                            functionCall: { name: fc.name, args: fc.args },
+                        }))
+                        : [{ text: accumulatedText }],
+                });
+                if (!hasToolCalls) {
+                    finalAnswer = accumulatedText;
+                    break;
+                }
+                const functionResponses = await this.executeToolCalls(accumulatedFunctionCalls, hooks);
+                this.history.push({ role: 'user', parts: functionResponses });
+            }
+            catch (e) {
+                if (hooks?.onError)
+                    hooks.onError(e);
+                finalAnswer = `Generation Error: ${e.message}`;
+                break;
+            }
+        }
+        if (iterations >= maxIterations) {
+            finalAnswer = finalAnswer || 'Max iterations (30) exceeded without a final answer.';
+        }
+        return finalAnswer;
+    }
+}

package/dist/agent/Tool.d.ts

@@ -0,0 +1,36 @@
+import { Type } from '@google/genai';
+/**
+ * Interface defining the parameters schema for a tool.
+ * We use a subset of the Open API/JSON Schema specifically used by Google GenAI.
+ */
+export interface ToolParameters {
+    type: Type | string;
+    properties?: Record<string, any>;
+    required?: string[];
+    description?: string;
+    enum?: string[];
+    items?: ToolParameters;
+}
+/**
+ * An abstraction of the Claude Code Tool system, adapted for Generation AI.
+ */
+export interface Tool<P = any, R = any> {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    /**
+     * Whether this tool should require user confirmation in the CLI / UI before running.
+     */
+    requiresConfirmation?: boolean;
+    /**
+     * Evaluated when the LLM triggers the tool.
+     * @param params Validated arguments from the LLM.
+     * @returns Resolves with JSON-serializable outputs or string.
+     */
+    execute: (params: P) => Promise<R>;
+}
+/**
+ * Converts a Tool definition into a format accepted by @google/genai tool arrays.
+ */
+export declare function convertToGenAITool(tool: Tool): any;
+//# sourceMappingURL=Tool.d.ts.map

package/dist/agent/Tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../../src/agent/Tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,cAAc,CAAC;IAC3B;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,GAAG,CAUlD"}

package/dist/agent/Tool.js

@@ -0,0 +1,14 @@
+/**
+ * Converts a Tool definition into a format accepted by @google/genai tool arrays.
+ */
+export function convertToGenAITool(tool) {
+    return {
+        functionDeclarations: [
+            {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        ],
+    };
+}

package/dist/agent/contextCompaction.d.ts

@@ -0,0 +1,9 @@
+import { Content, GoogleGenAI } from '@google/genai';
+/**
+ * Coding-session-aware context compaction.
+ * Summarizes the old portion of the conversation history while preserving
+ * key artifacts: file paths touched, errors encountered, fixes applied,
+ * and design decisions made. Mimics Claude Code's context sliding-window.
+ */
+export declare function compactHistory(ai: GoogleGenAI, history: Content[], model?: string, preserveCount?: number): Promise<Content[]>;
+//# sourceMappingURL=contextCompaction.d.ts.map

package/dist/agent/contextCompaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextCompaction.d.ts","sourceRoot":"","sources":["../../src/agent/contextCompaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,OAAO,EAAE,EAClB,KAAK,GAAE,MAA2B,EAClC,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CAoEpB"}

package/dist/agent/contextCompaction.js

@@ -0,0 +1,68 @@
+/**
+ * Coding-session-aware context compaction.
+ * Summarizes the old portion of the conversation history while preserving
+ * key artifacts: file paths touched, errors encountered, fixes applied,
+ * and design decisions made. Mimics Claude Code's context sliding-window.
+ */
+export async function compactHistory(ai, history, model = 'gemini-2.5-flash', preserveCount = 6) {
+    if (history.length <= preserveCount + 2) {
+        return history;
+    }
+    // Split history into old vs new
+    // Preserve the first system or initial context if it exists
+    const isFirstSystem = history[0].role === 'system';
+    const startIdx = isFirstSystem ? 1 : 0;
+    const toCompact = history.slice(startIdx, history.length - preserveCount);
+    const preserved = history.slice(history.length - preserveCount);
+    // Coding-aware summarization prompt
+    const summaryPrompt = {
+        role: 'user',
+        parts: [{
+                text: [
+                    'You are summarizing a coding agent session. Produce a concise but accurate ledger that preserves:',
+                    '1. Every file path that was read, created, or modified (list each with a one-line summary of changes).',
+                    '2. Any TypeScript/compiler errors encountered and their resolutions.',
+                    '3. Key design decisions or constraints established during the session.',
+                    '4. The current goal/task the agent was working on at the end of this segment.',
+                    '',
+                    'Format:',
+                    '## Files Touched',
+                    '- path/to/file.ts — [what changed]',
+                    '',
+                    '## Errors & Fixes',
+                    '- [error] → [fix applied]',
+                    '',
+                    '## Decisions & Constraints',
+                    '- [decision]',
+                    '',
+                    '## Current Task',
+                    '[one sentence]',
+                    '',
+                    '---',
+                    'Conversation to summarize:',
+                    JSON.stringify(toCompact, null, 2),
+                ].join('\n')
+            }]
+    };
+    try {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: [summaryPrompt],
+        });
+        const summaryText = response.text || 'No summary generated.';
+        const compactedNode = {
+            role: 'user',
+            parts: [{
+                    text: `[SYSTEM] The following is a compacted summary of previous interactions:\n${summaryText}`
+                }]
+        };
+        const newHistory = isFirstSystem ? [history[0]] : [];
+        newHistory.push(compactedNode);
+        newHistory.push(...preserved);
+        return newHistory;
+    }
+    catch (error) {
+        console.warn('Compaction failed. Returning original history.', error);
+        return history;
+    }
+}

package/dist/agent/tools/coding.d.ts

@@ -0,0 +1,15 @@
+import { Tool } from '../Tool.js';
+declare function isSafeCommand(cmd: string): boolean;
+export declare const readFileTool: Tool;
+export declare const writeFileTool: Tool;
+export declare const patchFileTool: Tool;
+export declare const listDirectoryTool: Tool;
+export declare const searchFilesTool: Tool;
+export declare const runCommandTool: Tool;
+/** Override requiresConfirmation for safe commands at runtime */
+export declare function createSmartRunCommandTool(): Tool;
+export declare const getFileTreeTool: Tool;
+/** All tools suitable for coding-mode agent sessions */
+export declare const ALL_CODING_TOOLS: Tool[];
+export { isSafeCommand };
+//# sourceMappingURL=coding.d.ts.map

package/dist/agent/tools/coding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding.d.ts","sourceRoot":"","sources":["../../../src/agent/tools/coding.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAyBlC,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG3C;AAMD,eAAO,MAAM,YAAY,EAAE,IAqC1B,CAAC;AAMF,eAAO,MAAM,aAAa,EAAE,IA0B3B,CAAC;AAMF,eAAO,MAAM,aAAa,EAAE,IA+C3B,CAAC;AAMF,eAAO,MAAM,iBAAiB,EAAE,IA8C/B,CAAC;AAMF,eAAO,MAAM,eAAe,EAAE,IA8C7B,CAAC;AAMF,eAAO,MAAM,cAAc,EAAE,IAmD5B,CAAC;AAEF,iEAAiE;AACjE,wBAAgB,yBAAyB,IAAI,IAAI,CAQhD;AAMD,eAAO,MAAM,eAAe,EAAE,IAkD7B,CAAC;AAMF,wDAAwD;AACxD,eAAO,MAAM,gBAAgB,EAAE,IAAI,EAQlC,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}