jeopi-cli 16.2.13 → 16.2.14

package/dist/types/stt/transcriber.d.ts

@@ -1,14 +0,0 @@
-export interface TranscribeOptions {
-    modelName?: string;
-    language?: string;
-    signal?: AbortSignal;
-}
-/**
- * Transcribe a WAV file using the local ONNX Whisper worker.
- *
- * Decodes the WAV to a 16 kHz mono Float32Array in-process (no Python, no
- * ffmpeg) and routes it to the warm speech worker, which keeps the model loaded
- * across calls. Honors `options.signal` (abort) and applies an internal timeout
- * with the same semantics as the previous Python path.
- */
-export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/stt/wav.d.ts

@@ -1,29 +0,0 @@
-/**
- * Minimal WAV (RIFF/PCM) decoder producing the Float32Array @ 16 kHz mono that
- * transformers.js `automatic-speech-recognition` expects. Ports the decode/
- * mono-mix/resample logic from the retired Python `transcribe.py` (which read
- * via the stdlib `wave` module) so STT no longer shells out to Python.
- *
- * Supported sample formats: PCM uint8 (8-bit), int16 (16-bit), int32 (32-bit),
- * and IEEE float32 (format tag 3). Any number of channels is mixed down to mono.
- */
-/** transformers.js Whisper feature extractor operates at 16 kHz. */
-export declare const TARGET_SAMPLE_RATE = 16000;
-/**
- * Resample via linear interpolation, mirroring the Python `np.interp` over
- * `linspace(0, n-1, targetLen)` against `arange(n)`.
- */
-export declare function resampleLinear(input: Float32Array, fromRate: number, toRate: number): Float32Array;
-/**
- * Decode a WAV byte buffer into a 16 kHz mono Float32Array suitable for the
- * transformers.js Whisper pipeline.
- */
-export declare function decodeWavToMono16k(buffer: ArrayBuffer): Float32Array;
-/**
- * Decode interleaved little-endian signed 16-bit PCM bytes into normalized
- * [-1, 1] mono float samples. The live recorder streams raw s16le frames from
- * sox/ffmpeg/arecord stdout (no RIFF container), so this is the hot-path
- * counterpart to {@link decodeWavToMono16k}. `bytes` MUST be 2-byte aligned;
- * callers buffer any trailing odd byte across chunk boundaries.
- */
-export declare function decodePcmS16LE(bytes: Uint8Array): Float32Array;

package/dist/types/subprocess/worker-client.d.ts

@@ -1,149 +0,0 @@
-import type { Subprocess } from "bun";
-/**
- * Shared lifecycle scaffolding for the ONNX inference subprocess clients
- * (mnemopi embeddings, speech-to-text, tiny-model titles/completions, TTS).
- * Each runs `onnxruntime-node` inside a dedicated Bun child process so the NAPI
- * constructor/finalizer never executes in the main agent address space — those
- * destructors segfault Bun on shutdown (issues #1606 / #1607 / #3031).
- *
- * Only the genuinely identical pieces live here: the worker-handle shape, the
- * spawn-command resolution, the parent-env snapshot, the `Bun.spawn` wiring,
- * the inline "worker unavailable" stub, and the ping/pong smoke probe. Each
- * client keeps its own divergent request/response correlation, streaming, and
- * teardown semantics.
- */
-/** Minimal inbound contract shared by every worker: a correlated `ping`. */
-export type WorkerInboundBase = {
-    type: "ping";
-    id: string;
-};
-/** Structured log line forwarded from a worker to the parent logger. */
-export type WorkerLogMessage = {
-    type: "log";
-    level: "debug" | "warn" | "error";
-    msg: string;
-    meta?: Record<string, unknown>;
-};
-/** Minimal outbound contract shared by every worker: `pong`, `error`, `log`. */
-export type WorkerOutboundBase = {
-    type: "pong";
-    id: string;
-} | {
-    type: "error";
-    id: string;
-    error: string;
-} | WorkerLogMessage;
-/**
- * Parent-side view of a worker subprocess: send typed inbound messages,
- * subscribe to outbound messages and worker errors, and hard-terminate.
- */
-export interface WorkerHandle<Inbound, Outbound> {
-    send(message: Inbound): void;
-    onMessage(handler: (message: Outbound) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
-    terminate(): Promise<void>;
-}
-/**
- * A {@link WorkerHandle} that can also be (un)referenced so a pending request
- * keeps the parent event loop alive while an idle worker never blocks exit.
- */
-export interface RefCountedWorkerHandle<Inbound, Outbound> extends WorkerHandle<Inbound, Outbound> {
-    /** Re-reference the subprocess so a pending request keeps the parent event loop alive. */
-    ref(): void;
-    /** Drop the reference once the worker is idle so it never blocks process exit. */
-    unref(): void;
-}
-/** The raw spawned subprocess plus the parent-side fan-out sets. */
-export interface SpawnedSubprocess<Outbound> {
-    proc: Subprocess<"ignore", "ignore", "ignore">;
-    inbound: Set<(message: Outbound) => void>;
-    errors: Set<(error: Error) => void>;
-    /**
-     * Flipped to `true` right before the deliberate SIGKILL so `onExit` can
-     * distinguish the expected hard-kill from a crash (SIGSEGV from a native
-     * fault, OOM SIGKILL, operator `kill -9`). Only the latter surfaces as a
-     * worker error so callers don't await forever.
-     */
-    intentionalExit: {
-        value: boolean;
-    };
-}
-export interface WorkerSpawnCommand {
-    cmd: string[];
-    cwd?: string;
-}
-/**
- * Cold-starting a worker from a compiled binary (decompress + module graph
- * load) is slow on contended CI runners; the probe only proves the worker
- * spawns and ponges, so a generous bound removes flakes without weakening it.
- */
-export declare const SMOKE_TEST_TIMEOUT_MS = 30000;
-/**
- * Resolve the command used to relaunch the agent CLI into worker mode. In a
- * compiled binary the entry point is the binary itself; otherwise re-enter the
- * declared worker-host entry with a cwd-relative script path (Bun's subprocess
- * IPC is more reliable that way under `bun test`), falling back to this
- * package's own `src/cli.ts` when no host entry is declared (bun test, SDK
- * embedding).
- */
-export declare function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand;
-/**
- * Snapshot the parent environment for the child. `process.env` carries
- * `undefined` slots that `Bun.spawn` rejects, so filter them out; an optional
- * `overlay` (e.g. the tiny-model device/dtype vars) wins over inherited keys.
- */
-export declare function workerEnvFromParent(overlay?: Record<string, string>): Record<string, string>;
-/**
- * Spawn an inference worker subprocess and wire its IPC fan-out. The child
- * inherits no stdio (native model runtimes may otherwise print progress or
- * decoded text and corrupt the chat scrollback) and is `unref`'d outside `bun
- * test` so an idle worker never blocks process exit. `exitLabel` prefixes the
- * worker-error message surfaced for an unexpected (non-intentional) exit.
- */
-export declare function createWorkerSubprocess<Outbound>(options: {
-    spawnCommand: WorkerSpawnCommand;
-    env: Record<string, string>;
-    exitLabel: string;
-}): SpawnedSubprocess<Outbound>;
-/**
- * Wrap a {@link SpawnedSubprocess} as a {@link WorkerHandle}. The `send`
- * strategy is injected so each client keeps its exact IPC-send behaviour (e.g.
- * `safeSend` vs an inline guarded `proc.send`). `terminate()` SIGKILLs: the
- * point of subprocess isolation is that the parent never runs
- * `onnxruntime-node`'s NAPI finalizer (it crashes Bun on Windows), so the OS
- * reclaims the model memory instead. The intentional-exit flag is flipped
- * *before* the kill so `onExit` can tell it apart from a native crash.
- */
-export declare function createWorkerHandle<Inbound, Outbound>(spawned: SpawnedSubprocess<Outbound>, send: (message: Inbound) => void): WorkerHandle<Inbound, Outbound>;
-/**
- * A stand-in handle used when the worker subprocess cannot be spawned. It
- * ponges `ping` (so the smoke probe and readiness checks still resolve) and
- * answers every other request with the spawn error so callers fail fast
- * instead of awaiting forever.
- */
-export declare function createUnavailableWorker<Inbound extends {
-    type: string;
-    id: string;
-}, Outbound extends {
-    type: string;
-}>(error: unknown): WorkerHandle<Inbound, Outbound>;
-/**
- * Spawn a worker handle, falling back to {@link createUnavailableWorker} (after
- * a warning) when the subprocess cannot be created so the feature degrades
- * gracefully instead of throwing into callers.
- */
-export declare function spawnWorkerOrUnavailable<Handle>(spawn: () => Handle, unavailable: (error: unknown) => Handle, warnMessage: string): Handle;
-/** Forward a worker's structured `log` message to the matching logger level. */
-export declare function logWorkerMessage(message: WorkerLogMessage): void;
-/**
- * Drive the ping/pong readiness probe wired into `jeopi --smoke-test`: send one
- * `ping`, resolve on the first `pong` (ignoring `log` chatter), and reject on
- * any other message, a worker error, or the timeout. Always tears the handle
- * down on the way out. `label` prefixes the failure messages.
- */
-export declare function smokeTestWorker<Inbound extends {
-    type: string;
-    id: string;
-}, Outbound extends {
-    type: string;
-}>(handle: WorkerHandle<Inbound, Outbound>, label: string, timeoutMs: number): Promise<void>;

package/dist/types/subprocess/worker-runtime.d.ts

@@ -1,107 +0,0 @@
-import type { ProgressInfo } from "@huggingface/transformers";
-/**
- * Child-side scaffolding shared by the ONNX inference worker bodies
- * (`stt/asr-worker`, `tiny/worker`, `tts/tts-worker`). These are the helpers
- * that run inside the spawned subprocess: error serialization, structured log
- * and progress reporting over the worker's typed transport, side-runtime
- * install (sharp stubbing + module-resolver patch), once-per-process runtime
- * memoization, and the Transformers.js runtime loader. The parent/client-side
- * complement lives in `worker-client.ts`.
- *
- * Each worker keeps its own strongly-typed transport / model-key / progress
- * event; the structural {@link WorkerLogTransport} / {@link WorkerProgressTransport}
- * interfaces below are the minimal shapes these helpers need, and every worker's
- * concrete transport satisfies them.
- */
-export declare const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
-export declare function errorText(error: unknown): string;
-export declare function errorMessage(error: unknown): string;
-export type WorkerLogLevel = "debug" | "warn" | "error";
-/** Minimal transport surface a worker exposes for forwarding log lines. */
-export interface WorkerLogTransport {
-    send(message: {
-        type: "log";
-        level: WorkerLogLevel;
-        msg: string;
-        meta?: Record<string, unknown>;
-    }): void;
-}
-export declare function sendLog(transport: WorkerLogTransport, level: WorkerLogLevel, msg: string, meta?: Record<string, unknown>): void;
-/**
- * Generic worker progress event. Each worker's protocol declares an identical
- * shape with its own `modelKey` type; this is the parameterized version the
- * shared helpers emit, structurally assignable to each protocol's event.
- */
-export interface WorkerProgressEvent<K> {
-    modelKey: K;
-    status: "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
-    name?: string;
-    file?: string;
-    progress?: number;
-    loaded?: number;
-    total?: number;
-    files?: Record<string, {
-        loaded: number;
-        total: number;
-    }>;
-    task?: string;
-    model?: string;
-}
-/** Minimal transport surface a worker exposes for emitting progress events. */
-export interface WorkerProgressTransport<K> {
-    send(message: {
-        type: "progress";
-        id: string;
-        event: WorkerProgressEvent<K>;
-    }): void;
-}
-export declare function sendProgress<K>(transport: WorkerProgressTransport<K>, id: string, modelKey: K, info: ProgressInfo): void;
-/**
- * If a model is already warming/warm in `cache`, replay a `ready` progress
- * event for this request once it resolves and return the cached promise so the
- * caller can short-circuit; otherwise return `undefined`.
- */
-export declare function replayCachedReady<K, M>(cache: Map<K, Promise<M>>, modelKey: K, transport: WorkerProgressTransport<K>, requestId: string, task: string, model: string): Promise<M> | undefined;
-/**
- * Stub `sharp` (the speech/text pipelines are not image codecs, so the native
- * image dependency is dead weight) and patch the module resolver so a side
- * runtime's bare requires resolve against its own `node_modules`. Returns the
- * runtime's `node_modules` directory.
- */
-export declare function installSharpStubResolver(runtimeDir: string): Promise<string>;
-/**
- * Lazily resolve (and memoize) the transformers version spec. In the `catalog:`
- * case {@link resolveTransformersVersionSpec} `require`s the installed
- * `@huggingface/transformers/package.json`, so it is only ever touched on the
- * compiled-binary runtime-install path — loading a worker (smoke-test ping,
- * online path) never triggers the transformers resolve/install dance.
- */
-export declare function getTransformersVersionSpec(): string;
-/** The subset of the Transformers.js module surface {@link configureTransformers} touches. */
-interface ConfigurableTransformers {
-    env: {
-        cacheDir?: string;
-        allowLocalModels?: boolean;
-        logLevel?: unknown;
-    };
-    LogLevel: {
-        ERROR: unknown;
-    };
-}
-/**
- * Memoize an async runtime load so it runs at most once per process, clearing
- * the cache on failure so a later call can retry. Each worker holds one
- * instance per runtime it loads.
- */
-export declare class MemoizedRuntime<T> {
-    #private;
-    load(build: () => Promise<T>): Promise<T>;
-}
-/**
- * Load the `@huggingface/transformers` runtime into `holder` (memoized): from
- * the ambient install when running from source, or from a version-keyed side
- * runtime (resolved lazily at `runtimeDir()`) when running as a compiled binary.
- * The result is cast to the caller's concrete runtime type `T`.
- */
-export declare function loadTransformersRuntime<T extends ConfigurableTransformers, K>(holder: MemoizedRuntime<T>, transport: WorkerProgressTransport<K>, requestId: string, modelKey: K, runtimeDir: () => string): Promise<T>;
-export {};

package/dist/types/system-prompt.d.ts

@@ -1,128 +0,0 @@
-/**
- * System prompt construction and project context loading
- */
-import type { AgentTool } from "jeopi-agent-core";
-import type { ToolExample, TSchema } from "jeopi-ai";
-import type { Personality, SkillsSettings } from "./config/settings";
-import { type Skill } from "./extensibility/skills";
-import { type ActiveRepoContext } from "./utils/active-repo-context";
-import { type WorkspaceTree } from "./workspace-tree";
-interface AlwaysApplyRule {
-    name: string;
-    content: string;
-    path: string;
-}
-/** Discover TITLE_SYSTEM.md file for automatic session-title prompt overrides */
-export declare function discoverTitleSystemPromptFile(cwd?: string): string | undefined;
-/** Resolve input as file path or literal string */
-export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
-export interface LoadContextFilesOptions {
-    /** Working directory to start walking up from. Default: getProjectDir() */
-    cwd?: string;
-}
-/**
- * Load all project context files using the capability API.
- * Returns {path, content, depth} entries for all discovered context files.
- * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
- */
-export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
-    path: string;
-    content: string;
-    depth?: number;
-}>>;
-/**
- * Load the effective system prompt customization from SYSTEM.md.
- * Project-level SYSTEM.md overrides user-level SYSTEM.md.
- */
-export declare function loadSystemPromptFiles(options?: LoadContextFilesOptions): Promise<string | null>;
-export declare const DEFAULT_SYSTEM_PROMPT_TOOL_NAMES: readonly ["read", "bash", "eval", "edit", "write"];
-export interface SystemPromptToolMetadata {
-    label: string;
-    description: string;
-    /** Tool name the model sees on the provider wire. Defaults to the internal tool name. */
-    wireName?: string;
-    /** Tool parameters schema (Zod or JSON Schema), fed to the verbose inventory renderer. */
-    parameters?: TSchema;
-    /** Illustrative examples rendered into the verbose inventory. */
-    examples?: readonly ToolExample[];
-}
-export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTool>, overrides?: Partial<Record<string, Partial<SystemPromptToolMetadata>>>): Map<string, SystemPromptToolMetadata>;
-export interface BuildSystemPromptOptions {
-    /** Custom system prompt (replaces default). */
-    customPrompt?: string;
-    /** Already-loaded custom system prompt text; bypasses path resolution. */
-    resolvedCustomPrompt?: string;
-    /** Tools to include in prompt. */
-    tools?: Map<string, SystemPromptToolMetadata>;
-    /** Tool names to include in prompt. */
-    toolNames?: string[];
-    /** Text to append to system prompt. */
-    appendSystemPrompt?: string;
-    /** Already-loaded append prompt text; bypasses path resolution. */
-    resolvedAppendSystemPrompt?: string;
-    /** Inline full tool descriptors in the system prompt. Default: false */
-    inlineToolDescriptors?: boolean;
-    /**
-     * Whether provider-native tool calling is active (no owned/in-band syntax).
-     * When true and `inlineToolDescriptors` is false, the inventory renders as a
-     * compact tool-name list; otherwise it renders full `# Tool:` sections. Default: true
-     */
-    nativeTools?: boolean;
-    /** Skills settings for discovery. */
-    skillsSettings?: SkillsSettings;
-    /** Working directory. Default: getProjectDir() */
-    cwd?: string;
-    /** Pre-loaded context files (skips discovery if provided). */
-    contextFiles?: Array<{
-        path: string;
-        content: string;
-        depth?: number;
-    }>;
-    /** Skills provided directly to system prompt construction. */
-    skills?: Skill[];
-    /** Pre-loaded rulebook rules (descriptions, excluding TTSR and always-apply). */
-    rules?: Array<{
-        name: string;
-        description?: string;
-        path: string;
-        globs?: string[];
-    }>;
-    /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
-    intentField?: string;
-    /** Whether MCP tool discovery is active for this prompt build. */
-    mcpDiscoveryMode?: boolean;
-    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
-    mcpDiscoveryServerSummaries?: string[];
-    /** Encourage the agent to delegate via tasks unless changes are trivial. */
-    eagerTasks?: boolean;
-    /** When true, the Eager Tasks section uses the hard MUST/ONLY wording (`task.eager: always`) rather than the softer `preferred` nudge. */
-    eagerTasksAlways?: boolean;
-    /** Whether `task.batch` is enabled; gates batch-call guidance in the Eager Tasks section. */
-    taskBatch?: boolean;
-    /** Rules with alwaysApply=true — their full content is injected into the prompt. */
-    alwaysApplyRules?: AlwaysApplyRule[];
-    /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
-    secretsEnabled?: boolean;
-    /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
-    workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
-    /** Whether the local memory://root summary is active. */
-    memoryRootEnabled?: boolean;
-    /** Active model identifier (e.g. "anthropic/claude-opus-4") surfaced to the agent. */
-    model?: string;
-    /** Personality preset rendered into the default system prompt. "none" omits the block. Default: "default" */
-    personality?: Personality;
-    /** Whether to include the workspace directory tree in the system prompt. Default: false */
-    includeWorkspaceTree?: boolean;
-    /** Whether Mermaid fenced blocks render as terminal ASCII diagrams. Default: true */
-    renderMermaid?: boolean;
-    /** Pre-resolved nested active repo context. Undefined resolves from cwd. */
-    activeRepoContext?: ActiveRepoContext | null;
-}
-/** Result of building provider-facing system prompt messages. */
-export interface BuildSystemPromptResult {
-    /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
-    systemPrompt: string[];
-}
-/** Build the system prompt with tools, guidelines, and context */
-export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
-export {};

package/dist/types/system-prompt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/task/agents.d.ts

@@ -1,28 +0,0 @@
-import type { AgentDefinition, AgentSource } from "./types";
-export declare class AgentParsingError extends Error {
-    readonly source?: unknown;
-    constructor(error: Error, source?: unknown);
-    toString(): string;
-}
-/**
- * Parse an agent from embedded content.
- */
-export declare function parseAgent(filePath: string, content: string, source: AgentSource, level?: "fatal" | "warn" | "off"): AgentDefinition;
-/**
- * Load all bundled agents from embedded content.
- * Results are cached after first load.
- */
-export declare function loadBundledAgents(): AgentDefinition[];
-/**
- * Get a bundled agent by name.
- */
-export declare function getBundledAgent(name: string): AgentDefinition | undefined;
-/**
- * Get all bundled agents as a map keyed by name.
- */
-export declare function getBundledAgentsMap(): Map<string, AgentDefinition>;
-/**
- * Clear the bundled agents cache (for testing).
- */
-export declare function clearBundledAgentsCache(): void;
-export declare const BUNDLED_AGENTS: typeof loadBundledAgents;

package/dist/types/task/commands.d.ts

@@ -1,35 +0,0 @@
-export declare const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{
-    name: string;
-    content: string;
-}>;
-/** Workflow command definition */
-export interface WorkflowCommand {
-    name: string;
-    description: string;
-    instructions: string;
-    source: "bundled" | "user" | "project";
-    filePath: string;
-}
-/**
- * Load all bundled commands from embedded content.
- */
-export declare function loadBundledCommands(): WorkflowCommand[];
-/**
- * Discover all available commands.
- *
- * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
- */
-export declare function discoverCommands(cwd: string): Promise<WorkflowCommand[]>;
-/**
- * Get a command by name.
- */
-export declare function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined;
-/**
- * Expand command instructions with task input.
- * Replaces $@ with the provided input.
- */
-export declare function expandCommand(command: WorkflowCommand, input: string): string;
-/**
- * Clear the bundled commands cache (for testing).
- */
-export declare function clearBundledCommandsCache(): void;

package/dist/types/task/discovery.d.ts

@@ -1,17 +0,0 @@
-import type { AgentDefinition } from "./types";
-/** Result of agent discovery */
-export interface DiscoveryResult {
-    agents: AgentDefinition[];
-    projectAgentsDir: string | null;
-}
-/**
- * Discover agents from filesystem and merge with bundled agents.
- *
- * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
- * @param cwd - Current working directory for project agent discovery
- */
-export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;
-/**
- * Get an agent by name from discovered agents.
- */
-export declare function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined;