cogpit-memory 0.1.9 → 0.1.10

package/dist/lib/codex-patches.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCall } from "./types";
+/** Extract patch payloads passed to nested `tools.apply_patch(...)` calls in Codex exec scripts. */
+export declare function extractApplyPatchInputs(execSource: string): string[];
+/** Parse a Codex apply_patch string into per-file Edit/Write tool calls. */
+export declare function parseApplyPatch(patchText: string, callId: string, timestamp: string, cwd?: string): ToolCall[];
+/** Normalize direct and exec-wrapped Codex apply_patch calls into file tool calls. */
+export declare function parseCodexToolPatches(toolName: string, rawInput: string, callId: string, timestamp: string, cwd?: string): ToolCall[];
+/** Attribute an exec-wrapper patch failure without tainting earlier successful patch calls. */
+export declare function findFailedNestedPatchCallIds(output: string, wrapperIsError: boolean, calls: readonly ToolCall[]): Set<string>;

package/dist/lib/codex-tool-normalization.d.ts

@@ -0,0 +1,8 @@
+export declare function inferToolError(output: string | null): boolean;
+/** Normalize Codex update_plan input to TodoWrite format. */
+export declare function normalizePlanToTodos(input: Record<string, unknown>): Record<string, unknown>;
+/** Parse Codex custom_tool_call output JSON or structured content blocks. */
+export declare function parseCustomToolOutput(output: unknown): {
+    text: string;
+    isError: boolean;
+};

package/dist/lib/codex.d.ts

@@ -0,0 +1,30 @@
+import type { ParseSessionOptions, ParsedSession } from "./types";
+export { extractApplyPatchInputs, findFailedNestedPatchCallIds, parseApplyPatch, parseCodexToolPatches, } from "./codex-patches";
+export { parseCustomToolOutput } from "./codex-tool-normalization";
+interface CodexMetadata {
+    sessionId: string;
+    version: string;
+    gitBranch: string;
+    cwd: string;
+    model: string;
+    slug: string;
+    name: string;
+    branchedFrom?: {
+        sessionId: string;
+        turnIndex?: number | null;
+    };
+    firstUserMessage: string;
+    lastUserMessage: string;
+    timestamp: string;
+    lastTimestamp: string;
+    turnCount: number;
+    /** True when this session is a Codex sub-agent (spawned by spawn_agent) */
+    isSubagent: boolean;
+    /** Parent session ID for sub-agent sessions */
+    parentSessionId: string | null;
+    /** Canonical collaboration path for the agent that owns this rollout. */
+    agentPath: string;
+}
+export declare function isCodexSessionText(jsonlText: string): boolean;
+export declare function extractCodexMetadataFromLines(lines: string[]): CodexMetadata;
+export declare function parseCodexSession(jsonlText: string, options?: ParseSessionOptions): ParsedSession;

package/dist/lib/dirs.d.ts

@@ -0,0 +1,8 @@
+export declare const dirs: {
+    PROJECTS_DIR: string;
+    TEAMS_DIR: string;
+    TASKS_DIR: string;
+    CODEX_SESSIONS_DIR: string;
+};
+/** Default database path for the FTS5 search index. */
+export declare const DEFAULT_DB_PATH: string;

package/dist/lib/helpers.d.ts

@@ -0,0 +1,11 @@
+/** Find the JSONL file path for a session by searching all project directories. */
+export declare function findJsonlPath(sessionId: string): Promise<string | null>;
+export declare function matchSubagentToMember(leadSessionId: string, subagentFileName: string, members: Array<{
+    name: string;
+    agentType: string;
+    prompt?: string;
+}>): Promise<string | null>;
+export declare function projectDirToReadableName(dirName: string): {
+    path: string;
+    shortName: string;
+};

package/dist/lib/interactiveState.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Interactive prompt detection — plan approval and user question states.
+ */
+import type { ParsedSession, Turn } from "./types";
+export interface PlanApprovalState {
+    type: "plan";
+    allowedPrompts?: Array<{
+        tool: string;
+        prompt: string;
+    }>;
+}
+export interface UserQuestionState {
+    type: "question";
+    toolUseId: string;
+    questions: Array<{
+        question: string;
+        header?: string;
+        options: Array<{
+            label: string;
+            description?: string;
+        }>;
+        multiSelect?: boolean;
+    }>;
+}
+export type PendingInteraction = PlanApprovalState | UserQuestionState | null;
+/**
+ * Check if the previous turn's last tool call is the same interactive tool
+ * with a pending/error result -- indicates a stuck loop we should suppress.
+ */
+export declare function isStuckInteractiveLoop(turns: Turn[], toolName: string): boolean;
+/**
+ * Detect if the session is waiting for user interaction (plan approval or
+ * AskUserQuestion). Returns the interaction state or null.
+ */
+export declare function detectPendingInteraction(session: ParsedSession): PendingInteraction;

package/dist/lib/messageTypeGuards.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared message type guards for RawMessage discrimination.
+ *
+ * Previously duplicated between turnBuilder.ts and parser.ts to avoid circular
+ * dependencies. Extracted here as a dependency-free leaf module (imports only
+ * from ./types) so both files can share a single source of truth.
+ */
+import type { RawMessage, UserMessage, AssistantMessage, ProgressMessage, SystemMessage, SummaryMessage, QueueOperationMessage } from "./types";
+export declare function isUserMessage(msg: RawMessage): msg is UserMessage;
+export declare function isAssistantMessage(msg: RawMessage): msg is AssistantMessage;
+export declare function isProgressMessage(msg: RawMessage): msg is ProgressMessage;
+export declare function isSystemMessage(msg: RawMessage): msg is SystemMessage;
+export declare function isSummaryMessage(msg: RawMessage): msg is SummaryMessage;
+export declare function isQueueOperationMessage(msg: RawMessage): msg is QueueOperationMessage;
+export declare function isCompactBoundary(msg: RawMessage): msg is SystemMessage & {
+    subtype: "compact_boundary";
+};

package/dist/lib/metadata.d.ts

@@ -0,0 +1,31 @@
+import { type SessionStatusInfo } from "./sessionStatus";
+export declare function getSessionMeta(filePath: string): Promise<{
+    sessionId: string;
+    version: string;
+    gitBranch: string;
+    model: string;
+    slug: string;
+    cwd: string;
+    firstUserMessage: string;
+    lastUserMessage: string;
+    timestamp: string;
+    turnCount: number;
+    lineCount: number;
+    branchedFrom: {
+        sessionId: string;
+        turnIndex?: number | null;
+    } | undefined;
+}>;
+/**
+ * Read backward through a session JSONL to derive agent status.
+ * Scans in 4KB chunks from the tail, parsing one line at a time until it
+ * finds a meaningful message (assistant or non-meta user). This reads only
+ * as far as needed — typically one chunk — and uses the same
+ * deriveSessionStatus() function as the client side.
+ */
+export declare function getSessionStatus(filePath: string): Promise<SessionStatusInfo>;
+/**
+ * Search all user messages in a session file for a query string.
+ * Returns the first matching message snippet, or null if no match.
+ */
+export declare function searchSessionMessages(filePath: string, query: string): Promise<string | null>;

package/dist/lib/parser.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedSession, ImageBlock, ParseSessionOptions, UserContent } from "./types";
+export type { PendingInteraction } from "./interactiveState";
+export type { ParseSessionOptions } from "./types";
+export { detectPendingInteraction } from "./interactiveState";
+export declare function parseSession(jsonlText: string, options?: ParseSessionOptions): ParsedSession;
+/**
+ * Incrementally append new JSONL lines to an existing parsed session.
+ * Avoids re-parsing all turns from scratch — only re-processes the last
+ * (potentially incomplete) turn and any new messages.
+ */
+export declare function parseSessionAppend(existing: ParsedSession, newJsonlText: string): ParsedSession;
+export declare function getUserMessageText(content: UserContent | null): string;
+export declare function getUserMessageImages(content: UserContent | null): ImageBlock[];
+export declare function getToolColor(toolName: string): string;

package/dist/lib/pricingTiers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pricing tier constants and model-to-tier resolution.
+ *
+ * Sources: Claude Code v2.1.172 binary (decompiled JS bundle) for Anthropic
+ * models, and the official OpenAI model pricing pages for GPT models.
+ * Each model maps to a tier with five price points.
+ *
+ * Changes vs the old v2.1.53 table:
+ *  - Extended-context (>200k input) pricing is gone — flat pricing per model.
+ *  - New frontier tier for Fable 5 / Mythos 5 / Opus 4.8 ($10/$50).
+ *  - Sonnet 4.5/4.6 dropped to the $3/$15 tier (was $5/$25).
+ *  - Fast mode (usage.speed === "fast" on Opus 4.6/4.7) bills $30/$150;
+ *    Opus 4.8 fast bills the same as standard.
+ */
+export interface PricingTier {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+    webSearch: number;
+}
+export declare function resolveTier(model: string, speed?: string): PricingTier;
+/**
+ * Whether Cogpit has a published USD price for this model.
+ *
+ * Keep the historical Claude-family fallback for old rollouts whose model is
+ * absent or abbreviated, but never price a future/unknown GPT model as if it
+ * were Claude. That would create a precise-looking but invented dollar value.
+ */
+export declare function hasKnownPricing(model: string | null | undefined): boolean;

package/dist/lib/response.d.ts

@@ -0,0 +1,2 @@
+/** Parse a duration string like "5d", "12h", "30m" to milliseconds. */
+export declare function parseMaxAge(raw: string): number;

package/dist/lib/search-index.d.ts

@@ -0,0 +1,154 @@
+export interface IndexStats {
+    dbPath: string;
+    dbSizeBytes: number;
+    dbSizeMB: number;
+    indexedFiles: number;
+    indexedSessions: number;
+    indexedSubagents: number;
+    totalRows: number;
+    watcherRunning: boolean;
+    lastFullBuild: string | null;
+    lastUpdate: string | null;
+}
+export interface SearchHit {
+    sessionId: string;
+    filePath: string;
+    location: string;
+    snippet: string;
+    matchCount: number;
+}
+export declare class SearchIndex {
+    private db;
+    private dbPath;
+    projectsDir: string | null;
+    private _watcherRunning;
+    private _lastFullBuild;
+    private _lastUpdate;
+    private watcher;
+    private debounceTimers;
+    constructor(dbPath: string);
+    private initSchema;
+    getStats(): IndexStats;
+    /** Index tool call inputs and results under the given location prefix. */
+    private insertToolCalls;
+    /**
+     * Insert all searchable content from a parsed session into the FTS5 index.
+     * Shared by both `indexFile` (single-file) and `buildFull` (batch).
+     */
+    private insertSessionContent;
+    /**
+     * Parse a JSONL file and insert all searchable content into the FTS5 index.
+     * Idempotent: deletes old data for the file before re-indexing.
+     * All inserts run in a single transaction for performance.
+     */
+    indexFile(filePath: string, sessionId?: string, mtimeMs?: number, opts?: {
+        isSubagent?: boolean;
+        parentSessionId?: string | null;
+    }): void;
+    /**
+     * Query the FTS5 index and return structured search results.
+     *
+     * - FTS5 unicode61 tokenizer is case-insensitive by default.
+     * - When `caseSensitive` is true, a post-filter checks the original query
+     *   against the snippet text (exact case match).
+     * - When `maxAgeMs` is provided, only files whose mtime in `indexed_files`
+     *   falls within the window are included (join on source_file).
+     * - `sessionId` restricts results to a single session.
+     * - `limit` defaults to 200 and is clamped to a max of 200.
+     */
+    search(query: string, opts?: {
+        limit?: number;
+        sessionId?: string;
+        maxAgeMs?: number;
+        caseSensitive?: boolean;
+    }): SearchHit[];
+    /**
+     * Count total matching rows and distinct sessions for a query (without LIMIT).
+     * Used by the route to report accurate totalHits and sessionsSearched.
+     */
+    countMatches(query: string, opts?: {
+        sessionId?: string;
+        maxAgeMs?: number;
+    }): {
+        totalHits: number;
+        sessionsSearched: number;
+    };
+    /**
+     * Clear all indexed data and re-index every JSONL file under `projectsDir`.
+     * Structure: projectsDir/{projectName}/{sessionId}.jsonl
+     * Subagents:  projectsDir/{projectName}/{sessionId}/subagents/agent-{id}.jsonl
+     *
+     * Optimized: discovers all files first, then processes them in a single
+     * SQLite transaction with pre-prepared statements. This avoids the overhead
+     * of 3000+ individual transactions (each forcing a disk sync).
+     *
+     * Stores `projectsDir` as a class field so `rebuild()` can reuse it.
+     */
+    buildFull(projectsDir: string): void;
+    /**
+     * Incrementally re-index only files whose mtime has changed since last index.
+     * New files (not in indexed_files) are always indexed.
+     *
+     * WARNING: This walks ALL files under projectsDir and stats each one.
+     * On large session stores (3000+ files) this can take minutes.
+     * Prefer `updateRecent()` for CLI search paths.
+     */
+    updateStale(projectsDir: string): void;
+    /**
+     * Lightweight incremental update for CLI search paths.
+     *
+     * Still walks and stats all files via `discoverFiles`, but skips DB lookups
+     * for files with mtime <= the high-water mark that are already indexed.
+     * Caps re-indexing to `maxFiles` to prevent blocking on large backlogs
+     * (run `index rebuild` for a full catch-up).
+     */
+    updateRecent(projectsDir: string, maxFiles?: number): void;
+    /**
+     * Re-run buildFull using the previously stored projectsDir.
+     * No-op if projectsDir was never set.
+     */
+    rebuild(): void;
+    /**
+     * Walk the projects directory tree and invoke `callback` for every JSONL file.
+     *
+     * Directory structure:
+     *   projectsDir/
+     *     {projectName}/
+     *       {sessionId}.jsonl              <- session file
+     *       {sessionId}/subagents/
+     *         agent-{agentId}.jsonl        <- subagent file (recursive)
+     *
+     * Skips the "memory" directory.
+     */
+    private discoverFiles;
+    /**
+     * Recursively discover subagent JSONL files under the subagents directory
+     * that corresponds to `parentPath`.
+     *
+     * For a parent at `/path/to/session-1.jsonl`, looks for subagents at
+     * `/path/to/session-1/subagents/agent-*.jsonl`.
+     *
+     * Recurses up to `maxDepth` levels (default 4).
+     */
+    private discoverSubagents;
+    /**
+     * Start watching `projectsDir` for JSONL file changes.
+     * Runs `updateStale()` immediately for an initial sync, then sets up
+     * `fs.watch` with `{ recursive: true }` (macOS-compatible) to detect
+     * subsequent file changes and trigger debounced re-indexing.
+     */
+    startWatching(projectsDir: string): void;
+    /**
+     * Stop the file watcher and clear any pending debounce timers.
+     * Safe to call even when not watching (no-op).
+     */
+    stopWatching(): void;
+    /**
+     * Private helper: debounce re-indexing of a single file.
+     * Waits 2 seconds after the last change event for a given file path
+     * before actually calling `indexFile()`. This coalesces rapid writes
+     * (e.g. streaming JSONL appends) into a single index operation.
+     */
+    private debouncedReindex;
+    close(): void;
+}

package/dist/lib/sessionStats.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Session statistics computation — token usage aggregation and tool call tallying.
+ */
+import type { Turn, SessionStats } from "./types";
+export declare function createEmptySessionStats(turnCount: number): SessionStats;
+export declare function computeStats(turns: Turn[]): SessionStats;

package/dist/lib/sessionStatus.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Derives the current session status from raw JSONL messages.
+ * Walks backward from the last message to determine if the agent
+ * is idle, thinking, calling tools, etc.
+ *
+ * This is a pure function — status is always derived from data,
+ * never stored as app state.
+ */
+export type SessionStatus = "idle" | "thinking" | "tool_use" | "processing" | "completed" | "compacting" | "deferred";
+export interface SessionStatusInfo {
+    status: SessionStatus;
+    /** Name of the tool currently being used (if status is tool_use) */
+    toolName?: string;
+    /** Number of pending queue items (user messages waiting to be processed) */
+    pendingQueue?: number;
+    /** Why the session terminated (from Claude Code's terminal_reason). Only set for non-normal endings. */
+    terminalReason?: string;
+}
+/**
+ * Derive session status from raw JSONL message objects.
+ *
+ * **Provider dispatch:** The function auto-detects the session format by
+ * inspecting `rawMessages[0].type`. Codex sessions start with one of
+ * `session_meta | turn_context | event_msg | response_item` and are routed
+ * to `deriveCodexSessionStatus`. All other sessions are treated as Claude Code
+ * format. If a third provider is added, add a detection branch here and in
+ * `src/lib/providers/registry.ts`.
+ */
+export declare function deriveSessionStatus(rawMessages: Array<{
+    type: string;
+    [key: string]: unknown;
+}>): SessionStatusInfo;
+/** Human-readable label for terminal_reason values from Claude Code. */
+export declare function getTerminalReasonLabel(reason: string): string;
+/** Human-readable label for a session status. Returns null for "idle". */
+export declare function getStatusLabel(status: SessionStatus | undefined, toolName?: string, terminalReason?: string): string | null;

package/dist/lib/token-costs.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Token cost calculation library — single source of truth.
+ *
+ * Pricing is reverse-engineered from the Claude Code binary (v2.1.53) to match
+ * exactly what CC reports.  CC calculates cost per API call in the message_delta
+ * handler using final usage from the streaming response — but the JSONL only
+ * records the message_start placeholder usage (output_tokens is severely
+ * undercounted, thinking tokens are omitted entirely).  We compensate by
+ * estimating output from actual content (≈4 chars/token).
+ */
+import type { Turn, SubAgentMessage } from "./types";
+/** Approximate characters per token for content-based estimation. */
+export declare const CHARS_PER_TOKEN = 4;
+export interface CostInput {
+    model: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+    webSearchRequests?: number;
+    /** Fast-mode flag from usage.speed — "fast" bills a higher tier on Opus 4.6/4.7 */
+    speed?: string;
+}
+/**
+ * Calculate the cost of a single API call / turn.
+ *
+ * This is the single entry point for all cost calculations.  All other
+ * functions in the codebase should use this instead of computing cost
+ * themselves.
+ */
+export declare function calculateCost(c: CostInput): number;
+/**
+ * Backward-compatible wrapper.  Prefer `calculateCost()` for new code.
+ */
+export declare function calculateTurnCost(model: string | null, inputTokens: number, outputTokens: number, cacheCreationTokens: number, cacheReadTokens: number): number;
+/** Estimate thinking tokens from a turn's thinking blocks. */
+export declare function estimateThinkingTokens(turn: Turn): number;
+/** Estimate non-thinking output tokens (text + tool use JSON). */
+export declare function estimateVisibleOutputTokens(turn: Turn): number;
+/** Estimate total output tokens (thinking + visible). Uses max(estimated, reported). */
+export declare function estimateTotalOutputTokens(turn: Turn): number;
+/** Estimate output tokens for a sub-agent message. */
+export declare function estimateSubAgentOutput(sa: SubAgentMessage): number;
+/** Calculate cost for a turn using estimated output tokens. */
+export declare function calculateTurnCostEstimated(turn: Turn): number;
+/** Calculate cost for a sub-agent message using estimated output tokens. */
+export declare function calculateSubAgentCostEstimated(sa: SubAgentMessage): number;
+export declare function formatCost(usd: number): string;

package/dist/lib/turnBuilder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Turn builder — state machine that converts raw JSONL messages into Turn objects.
+ */
+import type { RawMessage, Turn } from "./types";
+export declare function buildTurns(messages: RawMessage[]): Turn[];