@germanescobar/anita 0.3.0

package/dist/agent/context-builder.js

@@ -0,0 +1,175 @@
+import { exec } from "node:child_process";
+import { formatSkillsForPrompt } from "../skills/skills.js";
+import { formatAgentInstructionsForPrompt, loadAgentInstructions, } from "./agents.js";
+const STATIC_SYSTEM_PROMPT = `You are Anita, a coding agent.
+
+You have these tools available:
+- read_file: Read file contents
+- write_file: Create or overwrite a file
+- edit_file: Replace a specific string in a file (read the file first)
+- delete_file: Delete a file
+- run_command: Run a shell command
+
+Instructions:
+- Use tools to explore and understand the codebase before making changes
+- Prefer rg for repository text searches when available; fall back to grep only when rg is unavailable
+- Always read a file before editing it
+- Run tests or checks after making changes when appropriate
+- Follow the instructions of the user without jumping ahead.
+- Do not print or publish secrets, credentials, tokens, private keys, environment values, or other sensitive data
+- Explain what you are doing briefly`;
+export class ContextBuilder {
+    workingDirectory;
+    runtimeContext;
+    constructor(workingDirectory, runtimeContext = {}) {
+        this.workingDirectory = workingDirectory;
+        this.runtimeContext = runtimeContext;
+    }
+    buildSystemPrompt() {
+        const skillsSection = formatSkillsForPrompt(this.runtimeContext.skills ?? []);
+        const agentInstructionsSection = formatAgentInstructionsForPrompt(loadAgentInstructions({
+            cwd: this.workingDirectory,
+            homeDir: this.runtimeContext.agentsHomeDir,
+            repositoryRoot: this.runtimeContext.agentsRepositoryRoot,
+        }));
+        return (STATIC_SYSTEM_PROMPT +
+            agentInstructionsSection +
+            this.buildUserSystemPromptSection() +
+            skillsSection +
+            this.buildEnvironmentFooter());
+    }
+    buildUserSystemPromptSection() {
+        const systemPrompt = this.runtimeContext.systemPrompt?.trim();
+        if (!systemPrompt)
+            return "";
+        return [
+            "\nAdditional system prompt from --system-prompt:",
+            "These instructions are subordinate to Anita's built-in safety rules, user instructions, and tool permission policy.",
+            systemPrompt,
+            "",
+        ].join("\n");
+    }
+    buildEnvironmentFooter() {
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, "0");
+        const day = String(now.getDate()).padStart(2, "0");
+        const date = `${year}-${month}-${day}`;
+        const cwd = this.workingDirectory.replace(/\\/g, "/");
+        return `\nCurrent date: ${date}\nCurrent working directory: ${cwd}`;
+    }
+    async buildDynamicContext() {
+        const gitContext = await this.getGitContext();
+        const environmentContext = this.buildEnvironmentContext();
+        const policyContext = this.buildPolicyContext();
+        return [
+            "Runtime context for the assistant. This is not a user request:",
+            environmentContext,
+            policyContext,
+            gitContext,
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    async buildMessagesWithDynamicContext(messages) {
+        const dynamicContext = await this.buildDynamicContext();
+        if (!dynamicContext)
+            return messages;
+        return [
+            {
+                role: "user",
+                content: [{ type: "text", text: dynamicContext }],
+            },
+            ...messages,
+        ];
+    }
+    async buildItemsWithDynamicContext(items) {
+        const dynamicContext = await this.buildDynamicContext();
+        if (!dynamicContext)
+            return items;
+        return [
+            {
+                type: "message",
+                role: "user",
+                content: dynamicContext,
+            },
+            ...items,
+        ];
+    }
+    buildEnvironmentContext() {
+        const shell = this.runtimeContext.shell ?? process.env.SHELL ?? "unknown";
+        const approvalMode = this.runtimeContext.approvalMode ?? "prompt";
+        const networkAccess = this.runtimeContext.networkAccess ?? "unknown";
+        const writeScope = this.runtimeContext.writeScope ??
+            "No explicit write scope is configured; use the working directory unless the user asks otherwise.";
+        return [
+            "Runtime:",
+            `Working directory: ${this.workingDirectory}`,
+            `Shell: ${shell}`,
+            `Approval mode: ${this.describeApprovalMode(approvalMode)}`,
+            `Network access: ${this.describeNetworkAccess(networkAccess)}`,
+            `Write scope: ${writeScope}`,
+        ].join("\n");
+    }
+    buildPolicyContext() {
+        const policyContext = this.runtimeContext.policyContext;
+        if (!policyContext)
+            return "";
+        return [
+            "Permission policy:",
+            `Default decision: ${this.describeDecision(policyContext.defaultDecision)}`,
+            ...policyContext.rules.map((rule) => `- ${rule.toolName}: ${this.describeDecision(rule.decision)} - ${rule.description}`),
+        ].join("\n");
+    }
+    describeApprovalMode(approvalMode) {
+        if (approvalMode === "auto") {
+            return "auto-approve policy decisions that request approval";
+        }
+        return "prompt before executing tool calls that require approval";
+    }
+    describeNetworkAccess(networkAccess) {
+        switch (networkAccess) {
+            case "available":
+                return "available";
+            case "unavailable":
+                return "unavailable";
+            case "unknown":
+                return "not declared; verify before relying on network access";
+        }
+    }
+    describeDecision(decision) {
+        switch (decision) {
+            case "allow":
+                return "allowed";
+            case "deny":
+                return "denied";
+            case "ask":
+                return "approval required";
+        }
+    }
+    async getGitContext() {
+        const isGit = await this.runQuiet("git rev-parse --is-inside-work-tree");
+        if (!isGit)
+            return "";
+        const [branch, status, diffStat] = await Promise.all([
+            this.runQuiet("git branch --show-current"),
+            this.runQuiet("git status --short"),
+            this.runQuiet("git diff --stat"),
+        ]);
+        const parts = ["Git context:"];
+        if (branch)
+            parts.push(`Branch: ${branch}`);
+        if (status)
+            parts.push(`Status:\n${status}`);
+        if (diffStat)
+            parts.push(`Diff:\n${diffStat}`);
+        return parts.join("\n");
+    }
+    runQuiet(cmd) {
+        return new Promise((resolve) => {
+            exec(cmd, { cwd: this.workingDirectory, timeout: 5000 }, (err, stdout) => {
+                resolve(err ? "" : stdout.trim());
+            });
+        });
+    }
+}

package/dist/agent/executor.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCall, ToolExecuteOptions, ToolResult } from "../types/tools.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { EventStore } from "../storage/event-store.js";
+import type { PolicyEngine } from "./policies.js";
+export type ApprovalCallback = (toolName: string, input: Record<string, unknown>) => Promise<boolean>;
+export declare class Executor {
+    private registry;
+    private policyEngine;
+    private eventStore;
+    private approvalCallback;
+    constructor(registry: ToolRegistry, policyEngine: PolicyEngine, eventStore: EventStore, approvalCallback: ApprovalCallback);
+    executeTool(sessionId: string, toolCall: ToolCall, options?: ToolExecuteOptions): Promise<ToolResult>;
+}

package/dist/agent/executor.js

@@ -0,0 +1,65 @@
+export class Executor {
+    registry;
+    policyEngine;
+    eventStore;
+    approvalCallback;
+    constructor(registry, policyEngine, eventStore, approvalCallback) {
+        this.registry = registry;
+        this.policyEngine = policyEngine;
+        this.eventStore = eventStore;
+        this.approvalCallback = approvalCallback;
+    }
+    async executeTool(sessionId, toolCall, options) {
+        const validationError = this.registry.validateInput(toolCall.name, toolCall.input);
+        if (validationError) {
+            await this.eventStore.append(sessionId, "tool_call", {
+                id: toolCall.id,
+                tool: toolCall.name,
+                input: toolCall.input,
+            });
+            await this.eventStore.append(sessionId, "tool_result", {
+                toolCallId: toolCall.id,
+                tool: toolCall.name,
+                content: validationError.content.slice(0, 2000),
+                isError: true,
+                metadata: validationError.metadata,
+            });
+            return validationError;
+        }
+        const decision = this.policyEngine.evaluate(toolCall.name, toolCall.input);
+        await this.eventStore.append(sessionId, "policy_decision", {
+            tool: toolCall.name,
+            input: toolCall.input,
+            decision,
+        });
+        if (decision === "deny") {
+            return {
+                content: `Tool "${toolCall.name}" was denied by policy.`,
+                isError: true,
+            };
+        }
+        if (decision === "ask") {
+            const approved = await this.approvalCallback(toolCall.name, toolCall.input);
+            if (!approved) {
+                return {
+                    content: `Tool "${toolCall.name}" was denied by user.`,
+                    isError: true,
+                };
+            }
+        }
+        await this.eventStore.append(sessionId, "tool_call", {
+            id: toolCall.id,
+            tool: toolCall.name,
+            input: toolCall.input,
+        });
+        const result = await this.registry.execute(toolCall.name, toolCall.input, options);
+        await this.eventStore.append(sessionId, "tool_result", {
+            toolCallId: toolCall.id,
+            tool: toolCall.name,
+            content: result.content.slice(0, 2000), // truncate for event log
+            isError: result.isError,
+            metadata: result.metadata,
+        });
+        return result;
+    }
+}

package/dist/agent/loop.d.ts

@@ -0,0 +1,54 @@
+import type { ModelProvider } from "../models/provider.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { EventStore } from "../storage/event-store.js";
+import type { SessionStore } from "../storage/session-store.js";
+import type { SessionState } from "../types/agent.js";
+import type { AttachmentContentBlock } from "../types/messages.js";
+import { ContextBuilder } from "./context-builder.js";
+import { Executor } from "./executor.js";
+export declare const DEFAULT_CONTEXT_BUDGET: ContextBudgetOptions;
+export interface ContextBudgetOptions {
+    compactAtRatio: number;
+    reservedResponseTokens: number;
+    keepRecentTokens: number;
+    minSummarizableTokens: number;
+    targetSummaryTokens: number;
+}
+export declare class AgentLoop {
+    private provider;
+    private executor;
+    private contextBuilder;
+    private registry;
+    private eventStore;
+    private sessionStore;
+    private streamJson;
+    private contextBudget;
+    private pendingTerminalDelta;
+    constructor(provider: ModelProvider, executor: Executor, contextBuilder: ContextBuilder, registry: ToolRegistry, eventStore: EventStore, sessionStore: SessionStore, streamJson?: boolean, contextBudget?: ContextBudgetOptions);
+    run(session: SessionState, userMessage: string, attachments?: AttachmentContentBlock[], signal?: AbortSignal): Promise<void>;
+    /**
+     * Record a coherent cancellation: persist the session at its last consistent
+     * point (no partial assistant turn or tool batch is appended), log the event,
+     * and notify the stream.
+     */
+    private handleCancellation;
+    private generateTitle;
+    private saveSession;
+    private buildModelContextItems;
+    private updateContextBudget;
+    private estimateConversationTokens;
+    private generateCompactionSummary;
+    private buildCompactedItems;
+    private findRecentTailSplitIndex;
+    private getCompactionThresholdTokens;
+    private appendCompactionSkipEvent;
+    private findSafeCompactionSplitIndex;
+    private startsInsideFunctionBatch;
+    private isFunctionBatchItem;
+    private createErrorToolResult;
+    private normalizeSession;
+    private getModelResponse;
+    private emitModelStreamEvent;
+    private emit;
+    private finishPendingTerminalDelta;
+}