billion-context-omp 0.1.0 → 0.1.2

package/dist/log.d.ts

@@ -0,0 +1,21 @@
+export declare function setDebugEnabled(enabled: boolean): void;
+export type LogLevel = "error" | "warn" | "info" | "debug";
+/** No-op: writeLine uses appendFileSync (stateless per call), so there is no
+ *  stream to close. Kept as a hook in case the backend switches to a
+ *  persistent write stream. Called on session_shutdown. */
+export declare function closeLogStream(): void;
+export declare function logError(scope: string, fields: Record<string, unknown>): void;
+export declare function logWarn(scope: string, fields: Record<string, unknown>): void;
+export declare function logInfo(scope: string, fields: Record<string, unknown>): void;
+export declare function logThrow(scope: string, err: unknown, extra?: Record<string, unknown>): void;
+export declare const debug: {
+    readonly enabled: boolean;
+    readonly logFile: string;
+    event(scope: string, fields: Record<string, unknown>): void;
+};
+export declare const logger: {
+    error: typeof logError;
+    warn: typeof logWarn;
+    info: typeof logInfo;
+    debug(scope: string, fields: Record<string, unknown>): void;
+};

package/dist/messages.d.ts

@@ -0,0 +1,65 @@
+import type { SessionEntry, SessionMessageEntry } from "@oh-my-pi/pi-coding-agent";
+import type { CoreMessage } from "acp-kernel";
+type AgentMessage = SessionMessageEntry["message"];
+export type { AgentMessage };
+export declare function entriesToCoreMessages(entries: SessionEntry[]): CoreMessage[];
+export declare function streamToCoreMessages(stream: AgentMessage[]): CoreMessage[];
+/** Map of toolCallId → result text for tool results in the stream. Used to
+ *  skip replaying compress calls that were REJECTED live ("No changes
+ *  applied") — only calls that actually created blocks should rebuild them. */
+export declare function toolResultTexts(stream: AgentMessage[]): Map<string, string>;
+export interface StreamCompressCall {
+    id: string;
+    ranges: {
+        startRef: string;
+        endRef: string;
+        summary: string;
+        topic?: string;
+        summaryMaxChars?: number;
+        compressCallId: string;
+    }[];
+}
+export declare function findCompressCalls(message: AgentMessage): StreamCompressCall[];
+export declare function extractText(content: unknown): string;
+export declare function messageIdentity(message: unknown): string;
+export declare function matchesStoredText(stored: string, visible: string): boolean;
+export declare function coreOutToAgentMessages(coreOut: CoreMessage[], originalById: Map<string, AgentMessage>): AgentMessage[];
+/** 1-based stream position encoded in a p-id ("p7" | "p7#tc1" → 7). */
+export declare function rawPos(rawId: string): number;
+/** Stable fingerprint of a covered span, computed from the deterministic core
+ *  projection: hash of the first and last covered CoreMessages' content
+ *  fields. Written into the compress tool's success result (which lives in
+ *  the stream) and re-verified on fold replay — if a host-side rewrite
+ *  (compaction, edit) shifted positions, the fingerprint mismatches and the
+ *  call is skipped instead of silently compressing the wrong messages.
+ *  Boundaries bind to the EXACT piece the ref names (parallel tool calls
+ *  split one stream message into several pieces sharing a position —
+ *  hashing "whatever is at that position" is position-collision-fragile). */
+export declare function spanFingerprint(coreMessages: CoreMessage[], startId: string, endId: string): string;
+export interface BlockLike {
+    blockId: string;
+    effectiveMessageIds: string[];
+}
+export declare function isBlockRef(ref: string): boolean;
+/** Resolve a range boundary ref to the EXACT raw id of the piece it names.
+ *  Message refs (mNNNNN) go through byRef; block refs (bN) resolve to the
+ *  earliest (min) or latest (max) covered message's raw id. "" = unresolved. */
+export declare function boundaryRaw(ref: string, byRef: Record<string, string>, blocks: BlockLike[], pick: "min" | "max"): string;
+/** Ranges too small to carry a meaningful summary (kernel minSummaryLength
+ *  is 50 chars; a 16-token message can't support one and nets a LOSS). The
+ * "compress all ranges in one call" nudge hint makes listing them a trap:
+ * the model bundles them, the batch fails atomically, nothing gets applied
+ * (observed live: 14-range batch rejected by a 43-char summary on a
+ * 16-token range). 200 tokens ≈ 800 chars of substance — comfortably above
+ * the summary floor while still listing every genuinely compressible range. */
+export declare const VIABLE_RANGE_MIN_TOKENS = 200;
+export declare function viableRanges<T extends {
+    tokens: number;
+}>(ranges: T[]): T[];
+/** One fingerprint per range (never filtered, "-" for unresolvable
+ *  boundaries) so replay-side index lookup stays aligned even for mixed
+ *  message/block boundary batches. Written into the compress tool result. */
+export declare function rangeFingerprints(ranges: Array<{
+    startRef: string;
+    endRef: string;
+}>, coreMessages: CoreMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];

package/dist/runtime.d.ts

@@ -0,0 +1,34 @@
+import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { type CompressionCore, type CompressionState, type Config, type CoreMessage, type Prompts } from "acp-kernel";
+import { type AdapterConfig } from "./config.js";
+import { type AgentMessage } from "./messages.js";
+export interface FoldResult {
+    state: CompressionState;
+    coreMessages: CoreMessage[];
+    originalById: Map<string, AgentMessage>;
+    streamLen: number;
+}
+export interface AcpRuntime {
+    core: CompressionCore;
+    adapter: AdapterConfig;
+    setAdapter(adapter: AdapterConfig): void;
+    prompts: Prompts;
+    setPrompts(prompts: Prompts): void;
+    liveContextLimit(ctx: ExtensionContext): number;
+    configFor(ctx: ExtensionContext): Config;
+    foldStream(ctx: ExtensionContext, stream: AgentMessage[]): FoldResult;
+    stateFor(ctx: ExtensionContext): Promise<{
+        state: CompressionState;
+        coreMessages: CoreMessage[];
+    }>;
+    commitFoldState(ctx: ExtensionContext, state: CompressionState, toolCallId?: string): void;
+    forgetSession(sid: string): void;
+    /** Rebuild blocks from the persisted session view at session_start so /acp
+   *  and acp_status show them BEFORE the first LLM call of a resumed session.
+   *  The slot is marked preview and always re-folded authoritatively at the
+   *  first context event (the live stream is the truth source, not the
+   *  persisted view). */
+    primeFold(ctx: ExtensionContext): void;
+    acquireLock(sid: string): Promise<() => void>;
+}
+export declare function createRuntime(adapter: AdapterConfig): AcpRuntime;

package/dist/search-index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Search index — bridges pi's session log into acp-kernel's search.
+ *
+ * Builds SearchDoc[] from:
+ *  1. All compression blocks (active AND inactive) — via blockDocs()
+ *  2. Historical messages that compression folded into a block summary.
+ *
+ * Which messages are searchable? Those covered by SOME block's
+ * effectiveMessageIds — i.e. messages that were compressed into a summary and
+ * are no longer individually visible. Messages still live in context (not in
+ * any block) are skipped: the model can already see them.
+ *
+ * We deliberately do NOT use pi's buildContextEntries for the visible check:
+ * ACP prunes messages itself (no pi `compaction` entry is written), so pi
+ * reports ALL entries as in-context. The ACP state is the source of truth.
+ */
+import { type CompressionState, type CoreMessage, type SearchDoc } from "acp-kernel";
+export declare function buildSearchDocs(coreMessages: CoreMessage[], state: CompressionState): SearchDoc[];

package/dist/search-tool.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+declare const SearchParams: import("@oh-my-pi/omptype").FluentType<{
+    limit?: number | undefined;
+    query: string;
+}, {
+    limit?: number | undefined;
+    query: string;
+}>;
+export declare function makeSearchTool(runtime: AcpRuntime): ToolDefinition<typeof SearchParams>;
+export {};

package/dist/status-tool.d.ts

@@ -0,0 +1,17 @@
+import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+declare const StatusParams: import("@oh-my-pi/omptype").FluentType<{
+    limit?: number | undefined;
+    scope?: "compressed" | "uncompressed" | undefined;
+    sort?: "age" | "size" | "time" | "tool" | undefined;
+    tool?: string | undefined;
+    view?: "messages" | "ranges" | undefined;
+}, {
+    limit?: number | undefined;
+    scope?: "compressed" | "uncompressed" | undefined;
+    sort?: "age" | "size" | "time" | "tool" | undefined;
+    tool?: string | undefined;
+    view?: "messages" | "ranges" | undefined;
+}>;
+export declare function makeStatusTool(runtime: AcpRuntime): ToolDefinition<typeof StatusParams>;
+export {};

package/dist/system-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { Prompts } from "acp-kernel";
+export declare function buildAcpSystemPrompt(prompts: Prompts): string;

package/dist/tokens.d.ts

@@ -0,0 +1,16 @@
+import { type CoreMessage } from "acp-kernel";
+export declare function estimateTextTokens(text: string): number;
+export declare function collectCoveredMessageIds(state: {
+    blocks: {
+        active: boolean;
+        effectiveMessageIds: string[];
+    }[];
+}): Set<string>;
+export declare function estimateTokens(messages: CoreMessage[], coveredIds?: Set<string>): number;
+export declare function lastUserMessageId(entries: {
+    id: string;
+    message?: {
+        role?: string;
+    };
+}[]): string | undefined;
+export declare function formatTokens(n: number): string;

package/dist/tool-guardrails.d.ts

@@ -0,0 +1,13 @@
+import { type ExtensionAPI, type ToolResultEvent } from "@oh-my-pi/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+export type BashToolResultEvent = Extract<ToolResultEvent, {
+    toolName: "bash";
+}>;
+export declare function isBashToolResult(e: ToolResultEvent): e is BashToolResultEvent;
+export declare function resolveBashTimeout(input: {
+    timeout?: number;
+}, defaultTimeout: number | undefined): number | undefined;
+export declare function capToolOutput(content: ToolResultEvent["content"], maxBytes: number | undefined, fullPath?: string): ToolResultEvent["content"] | undefined;
+export declare function detectBashTimeout(content: ToolResultEvent["content"]): number | undefined;
+export declare function appendTimeoutNotice(content: ToolResultEvent["content"], secs: number): ToolResultEvent["content"];
+export declare function wireToolGuardrails(pi: ExtensionAPI, runtime: AcpRuntime): void;

package/dist/update.d.ts

@@ -0,0 +1,2 @@
+export declare function findNpmRoot(extDir: string): string | undefined;
+export declare function checkForUpdate(autoUpdate: boolean, notify?: (msg: string) => void): Promise<void>;

package/dist/user-config.d.ts

@@ -0,0 +1,26 @@
+import type { Prompts } from "acp-kernel";
+import type { AdapterConfig, CompressConfig, DelegateConfig } from "./config.js";
+/** User-facing config keys (subset of AdapterConfig). Loaded from
+ *  ~/.<CONFIG_DIR_NAME>/acp-omp.json (global) and <cwd>/.<CONFIG_DIR_NAME>/acp-omp.json
+ *  (project-local overrides project-global). Project wins over global. */
+export interface UserAcpConfig {
+    debug?: boolean;
+    autoUpdate?: boolean;
+    modelContextLimit?: number;
+    toolBashDefaultTimeout?: number;
+    toolOutputMaxBytes?: number;
+    delegate?: boolean | DelegateConfig;
+    compress?: CompressConfig;
+    displayUsage?: "merged" | "separate";
+    prompts?: Partial<Prompts>;
+    /** Model for /compact summaries, as "provider:modelId" (e.g.
+     *  "zhipuai:glm-5.2"). Shortcut for compress.compressModel — normalized
+     *  into the nested path at load time. */
+    compressModel?: string;
+}
+/** Read global + project acp-omp.json, project overrides global. Returns {} on any
+ *  error (missing file, bad JSON) — never throws. */
+export declare function loadUserConfig(cwd: string): Promise<UserAcpConfig>;
+/** Merge user config onto an adapter config: user config wins for the keys it
+ *  sets. Used at session_start to apply runtime-discovered config. */
+export declare function applyUserConfig(adapter: AdapterConfig, user: UserAcpConfig): AdapterConfig;

package/package.json

@@ -1,67 +1,76 @@
 {
-  "name": "billion-context-omp",
-  "version": "0.1.0",
-  "description": "oh-my-pi (omp) client extension for billion-context. Routes omp's model traffic through a running billion-context proxy for incremental, reversible, prefix-cache-friendly context compression — and self-disables when it detects omp is already behind bili.",
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "bin": {
-    "bili-omp": "./dist/index.js"
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "README.md",
-    "README.zh-CN.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit --project tsconfig.build.json",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "context",
-    "compression",
-    "proxy",
-    "acp",
-    "acp-kernel",
-    "ai",
-    "agent",
-    "omp",
-    "oh-my-pi",
-    "pi",
-    "coding-agent",
-    "cli",
-    "anthropic",
-    "openai"
-  ],
-  "license": "MIT",
-  "author": "ranxianglei",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ranxianglei/billion-context-omp.git"
-  },
-  "homepage": "https://github.com/ranxianglei/billion-context-omp#readme",
-  "bugs": {
-    "url": "https://github.com/ranxianglei/billion-context-omp/issues"
-  },
-  "devDependencies": {
-    "tsup": "^8.0.0",
-    "typescript": "^5.5.0"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  }
+	"name": "billion-context-omp",
+	"version": "0.1.2",
+	"description": "One billion, not one million. Model-driven context management for the oh-my-pi (omp) coding agent.",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"omp": {
+		"extensions": [
+			"./dist/index.js"
+		]
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"README.zh-CN.md",
+		"LICENSE"
+	],
+	"sideEffects": false,
+	"homepage": "https://github.com/ranxianglei/billion-context-omp",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ranxianglei/billion-context-omp.git"
+	},
+	"bugs": {
+		"url": "https://github.com/ranxianglei/billion-context-omp/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"scripts": {
+		"test": "bun scripts/test.ts",
+		"typecheck": "tsc --noEmit",
+		"typecheck:tests": "tsc --noEmit -p tsconfig.test.json",
+		"typecheck:all": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
+		"build": "tsup && tsc --emitDeclarationOnly"
+	},
+	"keywords": [
+		"pi",
+		"omp",
+		"oh-my-pi",
+		"acp",
+		"context",
+		"compression",
+		"context-management",
+		"llm",
+		"pi-package"
+	],
+	"author": "ranxianglei",
+	"license": "MIT",
+	"type": "module",
+	"peerDependencies": {
+		"@oh-my-pi/pi-coding-agent": ">=17.0.0",
+		"@oh-my-pi/omptype": ">=17.0.0"
+	},
+	"devDependencies": {
+		"@oh-my-pi/omptype": "17.3.2",
+		"@oh-my-pi/pi-agent-core": "17.3.2",
+		"@oh-my-pi/pi-ai": "17.3.2",
+		"@oh-my-pi/pi-coding-agent": "17.3.2",
+		"@oh-my-pi/pi-utils": "17.3.2",
+		"@types/node": "^26.1.2",
+		"acp-kernel": "0.0.22",
+		"tsup": "^8.5.1",
+		"tsx": "^4.23.1",
+		"typescript": "^7.0.2"
+	}
 }