@cleocode/adapters 2026.4.10 → 2026.4.12

package/dist/providers/opencode/adapter.d.ts

@@ -1,83 +0,0 @@
-/**
- * OpenCode Adapter
- *
- * Main CLEOProviderAdapter implementation for OpenCode AI coding assistant.
- * Provides spawn, hooks, and install capabilities for CLEO integration.
- *
- * @task T5240
- */
-import type { AdapterCapabilities, AdapterHealthStatus, CLEOProviderAdapter } from '@cleocode/contracts';
-import { OpenCodeHookProvider } from './hooks.js';
-import { OpenCodeInstallProvider } from './install.js';
-import { OpenCodeSpawnProvider } from './spawn.js';
-/**
- * CLEO provider adapter for OpenCode AI coding assistant.
- *
- * Bridges CLEO's adapter system with OpenCode's native capabilities:
- * - Hooks: Maps OpenCode events (session.start, tool.complete, etc.) to CAAMP events
- * - Spawn: Launches subagent processes via the `opencode` CLI
- * - Install: Ensures AGENTS.md references for CLEO instruction files
- *
- * @remarks
- * OpenCode is the second-most feature-complete adapter after Claude Code,
- * supporting 10 canonical events through its JavaScript plugin system,
- * subagent spawning via the `opencode run` CLI command, and instruction
- * file management via AGENTS.md. It uniquely supports PreModel via the
- * `chat.params` event, which allows pre-inference parameter injection.
- */
-export declare class OpenCodeAdapter implements CLEOProviderAdapter {
-    /** Unique provider identifier. */
-    readonly id = "opencode";
-    /** Human-readable provider name. */
-    readonly name = "OpenCode";
-    /** Adapter version string. */
-    readonly version = "1.0.0";
-    /** Declared capabilities for this provider. */
-    capabilities: AdapterCapabilities;
-    /** Hook provider for CAAMP event mapping via OpenCode's plugin system. */
-    hooks: OpenCodeHookProvider;
-    /** Spawn provider for launching subagent processes via `opencode run`. */
-    spawn: OpenCodeSpawnProvider;
-    /** Install provider for managing AGENTS.md instruction files. */
-    install: OpenCodeInstallProvider;
-    /** Project directory this adapter was initialized with, or null. */
-    private projectDir;
-    /** Whether {@link initialize} has been called. */
-    private initialized;
-    constructor();
-    /**
-     * Initialize the adapter for a given project directory.
-     *
-     * Validates the environment by checking for the OpenCode CLI
-     * and OpenCode configuration directory.
-     *
-     * @param projectDir - Root directory of the project
-     */
-    initialize(projectDir: string): Promise<void>;
-    /**
-     * Dispose the adapter and clean up resources.
-     *
-     * Unregisters hooks and releases any tracked state.
-     */
-    dispose(): Promise<void>;
-    /**
-     * Run a health check to verify OpenCode is accessible.
-     *
-     * Checks:
-     * 1. Adapter has been initialized
-     * 2. OpenCode CLI is available in PATH
-     * 3. .opencode/ configuration directory exists in the project
-     *
-     * @returns Health status with details about each check
-     */
-    healthCheck(): Promise<AdapterHealthStatus>;
-    /**
-     * Check whether the adapter has been initialized.
-     */
-    isInitialized(): boolean;
-    /**
-     * Get the project directory this adapter was initialized with.
-     */
-    getProjectDir(): string | null;
-}
-//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/opencode/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/opencode/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAInD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAgB,YAAW,mBAAmB;IACzD,kCAAkC;IAClC,QAAQ,CAAC,EAAE,cAAc;IACzB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,cAAc;IAC3B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,+CAA+C;IAC/C,YAAY,EAAE,mBAAmB,CA2B/B;IAEF,0EAA0E;IAC1E,KAAK,EAAE,oBAAoB,CAAC;IAC5B,0EAA0E;IAC1E,KAAK,EAAE,qBAAqB,CAAC;IAC7B,iEAAiE;IACjE,OAAO,EAAE,uBAAuB,CAAC;IAEjC,oEAAoE;IACpE,OAAO,CAAC,UAAU,CAAuB;IACzC,kDAAkD;IAClD,OAAO,CAAC,WAAW,CAAS;;IAQ5B;;;;;;;OAOG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;;;;;OASG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IA2CjD;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG/B"}

package/dist/providers/opencode/hooks.d.ts

@@ -1,136 +0,0 @@
-/**
- * OpenCode Hook Provider
- *
- * Maps OpenCode's native hook events to CAAMP canonical hook events.
- * OpenCode supports 10 of 16 canonical events through its plugin system.
- *
- * Event translation uses CAAMP normalizer APIs:
- * - `toCanonical(nativeName, 'opencode')` for runtime event name resolution
- * - `getSupportedEvents('opencode')` to enumerate supported canonical events
- * - `getProviderHookProfile('opencode')` for the full provider profile
- *
- * OpenCode uses a JavaScript plugin system with event-prefixed names
- * (e.g. `event:session.created`) for some hooks and bare names for others.
- * The map is derived from `getProviderHookProfile('opencode').mappings` in
- * CAAMP 1.9.1. PostToolUseFailure, SubagentStart, SubagentStop, Notification,
- * and ConfigChange are not supported by OpenCode.
- *
- * @task T164
- * @epic T134
- */
-import type { AdapterHookProvider } from '@cleocode/contracts';
-/**
- * Hook provider for OpenCode.
- *
- * OpenCode registers hooks via its JavaScript plugin system at
- * `.opencode/plugins/`. Supported handler type: plugin (JavaScript).
- *
- * Event mapping is based on `getProviderHookProfile('opencode')` from
- * CAAMP 1.9.1. Async accessors (`getSupportedCanonicalEvents`,
- * `getProviderProfile`) call CAAMP directly when available.
- *
- * Since hooks are registered through the plugin system (managed by the install
- * provider), `registerNativeHooks` and `unregisterNativeHooks` track registration
- * state without performing filesystem operations.
- *
- * @remarks
- * OpenCode uses dot-delimited and `event:`-prefixed event names
- * (e.g. `event:session.created`, `tool.execute.before`) which differ
- * significantly from the PascalCase CAAMP canonical names. The static
- * event map covers all 10 supported events. Async CAAMP accessors
- * (`getSupportedCanonicalEvents`, `getProviderProfile`, `toNativeEvent`)
- * call the normalizer directly when available and fall back to the static map.
- *
- * @task T164
- * @epic T134
- */
-export declare class OpenCodeHookProvider implements AdapterHookProvider {
-    /** Whether hooks have been registered for the current session. */
-    private registered;
-    /**
-     * Map an OpenCode native event name to a CAAMP canonical hook event name.
-     *
-     * Looks up the native event name in the map derived from
-     * `getProviderHookProfile('opencode').mappings` (CAAMP 1.9.1).
-     * Returns null for unsupported events (PostToolUseFailure, SubagentStart,
-     * SubagentStop, Notification, ConfigChange).
-     *
-     * @param providerEvent - OpenCode native event (e.g. "event:session.created", "tool.execute.before")
-     * @returns CAAMP canonical event name, or null if unmapped
-     * @task T164
-     */
-    mapProviderEvent(providerEvent: string): string | null;
-    /**
-     * Register native hooks for a project.
-     *
-     * For OpenCode, hooks are registered via the plugin system
-     * (`.opencode/plugins/`), managed by the install provider.
-     * This method marks hooks as registered without performing filesystem operations.
-     *
-     * Iterating supported events is handled at install time using
-     * `getSupportedCanonicalEvents()` to enumerate all 10 supported hooks.
-     *
-     * @param _projectDir - Project directory (unused; config manages registration)
-     * @task T164
-     */
-    registerNativeHooks(_projectDir: string): Promise<void>;
-    /**
-     * Unregister native hooks.
-     *
-     * For OpenCode, this is a no-op since hooks are managed through the plugin
-     * system. Unregistration happens via the install provider's uninstall method.
-     *
-     * @task T164
-     */
-    unregisterNativeHooks(): Promise<void>;
-    /**
-     * Check whether hooks have been registered via `registerNativeHooks`.
-     */
-    isRegistered(): boolean;
-    /**
-     * Get the native→canonical event mapping for introspection and debugging.
-     *
-     * Returns the map derived from `getProviderHookProfile('opencode').mappings`
-     * (CAAMP 1.9.1). Use `getSupportedCanonicalEvents()` to enumerate canonical
-     * names via live CAAMP APIs.
-     *
-     * @returns Immutable record of native event name → canonical event name
-     */
-    getEventMap(): Readonly<Record<string, string>>;
-    /**
-     * Enumerate supported canonical events via CAAMP's `getSupportedEvents()`.
-     *
-     * Calls `getSupportedEvents('opencode')` from the CAAMP normalizer to get the
-     * authoritative list. OpenCode supports 10 of 16 canonical events via its
-     * plugin system. Falls back to the values of the static event map when
-     * CAAMP is unavailable at runtime.
-     *
-     * @returns Array of CAAMP canonical event names supported by OpenCode
-     * @task T164
-     */
-    getSupportedCanonicalEvents(): Promise<string[]>;
-    /**
-     * Retrieve the full provider hook profile from CAAMP.
-     *
-     * Calls `getProviderHookProfile('opencode')` from the CAAMP normalizer to
-     * get the complete profile: hook system type (`plugin`), config path
-     * (`.opencode/plugins/`), handler types, and all event mappings.
-     * Returns null when CAAMP is unavailable at runtime.
-     *
-     * @returns Provider hook profile or null if CAAMP is unavailable
-     * @task T164
-     */
-    getProviderProfile(): Promise<unknown | null>;
-    /**
-     * Translate a CAAMP canonical event to its OpenCode native name via CAAMP.
-     *
-     * Calls `toNative(canonical, 'opencode')` from the CAAMP normalizer.
-     * Returns null for unsupported events or when CAAMP is unavailable.
-     *
-     * @param canonical - CAAMP canonical event name (e.g. "PreToolUse")
-     * @returns OpenCode native event name or null
-     * @task T164
-     */
-    toNativeEvent(canonical: string): Promise<string | null>;
-}
-//# sourceMappingURL=hooks.d.ts.map

package/dist/providers/opencode/hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/providers/opencode/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAuC/D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,oBAAqB,YAAW,mBAAmB;IAC9D,kEAAkE;IAClE,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAItD;;;;;;;;;;;;OAYG;IACG,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7D;;;;;;;OAOG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C;;OAEG;IACH,YAAY,IAAI,OAAO;IAIvB;;;;;;;;OAQG;IACH,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAI/C;;;;;;;;;;OAUG;IACG,2BAA2B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAStD;;;;;;;;;;OAUG;IACG,kBAAkB,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IASnD;;;;;;;;;OASG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAU/D"}

package/dist/providers/opencode/index.d.ts

@@ -1,35 +0,0 @@
-/**
- * @packageDocumentation
- *
- * CLEO provider adapter for OpenCode AI coding assistant.
- * Default export is the adapter class for dynamic loading by AdapterManager.
- *
- * @task T5240
- */
-import { OpenCodeAdapter } from './adapter.js';
-export { OpenCodeAdapter } from './adapter.js';
-export { OpenCodeHookProvider } from './hooks.js';
-export { OpenCodeInstallProvider } from './install.js';
-export { OpenCodeSpawnProvider } from './spawn.js';
-export default OpenCodeAdapter;
-/**
- * Factory function for creating adapter instances.
- * Used by AdapterManager's dynamic import fallback.
- *
- * @remarks
- * This is the primary entry point for dynamic adapter loading.
- * AdapterManager calls this function when it resolves the opencode
- * provider via its import-based discovery mechanism.
- *
- * @returns A new {@link OpenCodeAdapter} instance ready for initialization
- *
- * @example
- * ```typescript
- * import { createAdapter } from '@cleocode/adapters/providers/opencode';
- *
- * const adapter = createAdapter();
- * await adapter.initialize('/path/to/project');
- * ```
- */
-export declare function createAdapter(): OpenCodeAdapter;
-//# sourceMappingURL=index.d.ts.map

package/dist/providers/opencode/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/opencode/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAe,eAAe,CAAC;AAE/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,IAAI,eAAe,CAE/C"}

package/dist/providers/opencode/install.d.ts

@@ -1,56 +0,0 @@
-/**
- * OpenCode Install Provider
- *
- * Handles CLEO installation into OpenCode environments:
- * - Ensures AGENTS.md has CLEO @-references
- *
- * @task T5240
- */
-import type { AdapterInstallProvider, InstallOptions, InstallResult } from '@cleocode/contracts';
-/**
- * Install provider for OpenCode.
- *
- * Manages CLEO's integration with OpenCode by:
- * 1. Ensuring AGENTS.md contains @-references to CLEO instruction files
- *
- * @remarks
- * Installation is idempotent -- running install multiple times on the same
- * project produces the same result. Only AGENTS.md is managed; OpenCode's
- * plugin system is handled separately by the hook provider.
- */
-export declare class OpenCodeInstallProvider implements AdapterInstallProvider {
-    /**
-     * Install CLEO into an OpenCode project.
-     *
-     * @param options - Installation options including project directory
-     * @returns Result describing what was installed
-     */
-    install(options: InstallOptions): Promise<InstallResult>;
-    /**
-     * Uninstall CLEO from the current OpenCode project.
-     *
-     * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
-     */
-    uninstall(): Promise<void>;
-    /**
-     * Check whether CLEO is installed in the current environment.
-     *
-     * Checks for CLEO references in AGENTS.md.
-     */
-    isInstalled(): Promise<boolean>;
-    /**
-     * Ensure AGENTS.md contains @-references to CLEO instruction files.
-     *
-     * Creates AGENTS.md if it does not exist. Appends any missing references.
-     *
-     * @param projectDir - Project root directory
-     */
-    ensureInstructionReferences(projectDir: string): Promise<void>;
-    /**
-     * Update AGENTS.md with CLEO @-references.
-     *
-     * @returns true if the file was created or modified
-     */
-    private updateInstructionFile;
-}
-//# sourceMappingURL=install.d.ts.map

package/dist/providers/opencode/install.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/providers/opencode/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKjG;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,sBAAsB;IACpE;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IAqB9D;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAEhC;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBrC;;;;;;OAMG;IACG,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpE;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;CA8B9B"}

package/dist/providers/opencode/spawn.d.ts

@@ -1,94 +0,0 @@
-/**
- * OpenCode Spawn Provider
- *
- * Implements AdapterSpawnProvider for OpenCode CLI.
- * Migrated from src/core/spawn/adapters/opencode-adapter.ts
- *
- * Uses `opencode run --agent ... --format json` to spawn subagent
- * processes. Processes run detached and are tracked by PID for
- * listing and termination.
- *
- * @task T5240
- */
-import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
-/**
- * Build the markdown content for an OpenCode agent definition file.
- *
- * OpenCode agents are defined as markdown files with YAML frontmatter
- * in the .opencode/agent/ directory.
- *
- * @remarks
- * The generated markdown uses YAML frontmatter with `mode: subagent`
- * and `hidden: true` so the agent does not appear in OpenCode's
- * interactive agent selection menu.
- *
- * @param description - Agent description for frontmatter
- * @param instructions - Markdown instructions body
- * @returns Complete agent definition markdown with YAML frontmatter
- *
- * @example
- * ```typescript
- * import { buildOpenCodeAgentMarkdown } from '@cleocode/adapters/providers/opencode/spawn';
- *
- * const md = buildOpenCodeAgentMarkdown(
- *   'CLEO task executor',
- *   '# Subagent\n\nExecute the delegated task.',
- * );
- * ```
- */
-export declare function buildOpenCodeAgentMarkdown(description: string, instructions: string): string;
-/**
- * Spawn provider for OpenCode.
- *
- * Spawns detached OpenCode CLI processes for subagent execution.
- * Each spawn ensures a CLEO subagent definition exists, then runs
- * `opencode run --format json --agent <name> --title <title> <prompt>`
- * as a detached, unref'd child process.
- *
- * @remarks
- * Before spawning, the provider ensures a `cleo-subagent` agent definition
- * exists in `.opencode/agent/`. If the definition cannot be created, it
- * falls back to the built-in `general` agent. Processes are tracked by
- * instance ID in an in-memory map and verified via `kill(pid, 0)` liveness
- * checks.
- */
-export declare class OpenCodeSpawnProvider implements AdapterSpawnProvider {
-    /** Map of instance IDs to tracked process info. */
-    private processMap;
-    /**
-     * Check if the OpenCode CLI is available in PATH.
-     *
-     * @returns true if `opencode` is found via `which`
-     */
-    canSpawn(): Promise<boolean>;
-    /**
-     * Spawn a subagent via OpenCode CLI.
-     *
-     * Ensures the CLEO subagent definition exists in the project's
-     * .opencode/agent/ directory, then spawns a detached OpenCode
-     * process. The process runs independently of the parent.
-     *
-     * @param context - Spawn context with taskId, prompt, and options
-     * @returns Spawn result with instance ID and status
-     */
-    spawn(context: SpawnContext): Promise<SpawnResult>;
-    /**
-     * List currently running OpenCode subagent processes.
-     *
-     * Checks each tracked process via kill(pid, 0) to verify it is still alive.
-     * Dead processes are automatically cleaned from the tracking map.
-     *
-     * @returns Array of spawn results for running processes
-     */
-    listRunning(): Promise<SpawnResult[]>;
-    /**
-     * Terminate a running spawn by instance ID.
-     *
-     * Sends SIGTERM to the tracked process. If the process is not found
-     * or has already exited, this is a no-op.
-     *
-     * @param instanceId - ID of the spawn instance to terminate
-     */
-    terminate(instanceId: string): Promise<void>;
-}
-//# sourceMappingURL=spawn.d.ts.map

package/dist/providers/opencode/spawn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/providers/opencode/spawn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAiB3F;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAY5F;AA0CD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAsB,YAAW,oBAAoB;IAChE,mDAAmD;IACnD,OAAO,CAAC,UAAU,CAAqC;IAEvD;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IASlC;;;;;;;;;OASG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAiExD;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAqB3C;;;;;;;OAOG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnD"}

package/dist/providers/shared/transcript-reader.d.ts

@@ -1,58 +0,0 @@
-/**
- * Shared transcript-reading utility for provider hook adapters.
- *
- * Several providers (Gemini CLI, Codex CLI) store session data in a
- * flat directory of JSON/JSONL files using the same role/content schema.
- * This module centralises the "find most-recent file, parse turns"
- * logic to avoid duplicating it in each hook provider.
- *
- * Usage:
- * ```ts
- * import { readLatestTranscript } from '../shared/transcript-reader.js';
- *
- * async getTranscript(_sessionId: string, _projectDir: string) {
- *   return readLatestTranscript(join(homedir(), '.gemini'));
- * }
- * ```
- *
- * @task T161
- * @epic T134
- */
-/**
- * Read the most recent JSON or JSONL session file from `providerDir` and
- * return its contents as a flat transcript string.
- *
- * Files are sorted in descending order by filename — this works naturally
- * for providers that embed timestamps in filenames. The most recently named
- * file is read first.
- *
- * Returns `null` when:
- * - `providerDir` does not exist or cannot be read
- * - No JSON/JSONL files are present
- * - The most recent file contains no parseable turns
- *
- * @remarks
- * This utility is shared by Gemini CLI and Codex CLI hook providers which
- * both store session data in the same flat JSON/JSONL format. Only the
- * most recent file is read to keep memory usage bounded.
- *
- * @param providerDir - Absolute path to the provider's session directory
- *   (e.g. `~/.gemini` or `~/.codex`).
- * @returns A plain-text transcript with lines of the form `role: content`,
- *   or `null` if no transcript could be extracted.
- *
- * @example
- * ```typescript
- * import { readLatestTranscript } from '../shared/transcript-reader.js';
- *
- * const transcript = await readLatestTranscript('/home/user/.gemini');
- * if (transcript) {
- *   console.log(transcript);
- * }
- * ```
- *
- * @task T161
- * @epic T134
- */
-export declare function readLatestTranscript(providerDir: string): Promise<string | null>;
-//# sourceMappingURL=transcript-reader.d.ts.map

package/dist/providers/shared/transcript-reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transcript-reader.d.ts","sourceRoot":"","sources":["../../../src/providers/shared/transcript-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoDH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BtF"}

package/dist/registry.d.ts

@@ -1,88 +0,0 @@
-/**
- * Adapter registry — discovers and provides access to provider manifests.
- *
- * Scans the providers/ directory for manifest.json files and returns
- * the discovered adapter manifests for use by AdapterManager.
- *
- * @task T5240
- */
-/**
- * Minimal manifest shape for provider discovery.
- *
- * @remarks
- * Each provider adapter ships a `manifest.json` in its directory under
- * `providers/`. The registry reads these at startup to populate the
- * adapter discovery surface. The shape is intentionally minimal -- only
- * the fields needed for dynamic loading and detection are required.
- */
-export interface AdapterManifest {
-    /** Unique provider identifier (e.g. "claude-code", "cursor"). */
-    id: string;
-    /** Human-readable display name for the provider. */
-    name: string;
-    /** Semantic version of the adapter. */
-    version: string;
-    /** Short description of what the provider integrates with. */
-    description: string;
-    /** Provider slug used for directory lookups. */
-    provider: string;
-    /** Relative path to the adapter's entry point module. */
-    entryPoint: string;
-    /** Capability flags declared by the adapter. */
-    capabilities: Record<string, unknown>;
-    /** Patterns used to auto-detect the provider in a project. */
-    detectionPatterns: Array<{
-        /** Detection strategy type (e.g. "file", "env"). */
-        type: string;
-        /** Glob or regex pattern to match. */
-        pattern: string;
-        /** Human-readable explanation of this detection rule. */
-        description: string;
-    }>;
-}
-/**
- * Get the manifests for all bundled provider adapters.
- *
- * @remarks
- * Scans the known provider directories for `manifest.json` files.
- * Providers whose manifests cannot be loaded (missing or malformed)
- * are silently skipped.
- *
- * @returns Array of adapter manifests for successfully loaded providers
- *
- * @example
- * ```typescript
- * import { getProviderManifests } from '@cleocode/adapters';
- *
- * const manifests = getProviderManifests();
- * for (const m of manifests) {
- *   console.log(`${m.id}: ${m.name} v${m.version}`);
- * }
- * ```
- */
-export declare function getProviderManifests(): AdapterManifest[];
-/**
- * Discover all available provider adapters.
- *
- * Returns a map of provider ID to adapter factory function.
- *
- * @remarks
- * Each factory lazily imports the provider module and constructs a new
- * adapter instance. This avoids loading all provider code upfront and
- * keeps startup fast.
- *
- * @returns Map of provider ID to async factory function that creates an adapter instance
- *
- * @example
- * ```typescript
- * import { discoverProviders } from '@cleocode/adapters';
- *
- * const providers = await discoverProviders();
- * const factory = providers.get('claude-code');
- * if (factory) {
- *   const adapter = await factory();
- * }
- * ```
- */
-export declare function discoverProviders(): Promise<Map<string, () => Promise<unknown>>>;
-//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,8DAA8D;IAC9D,iBAAiB,EAAE,KAAK,CAAC;QACvB,oDAAoD;QACpD,IAAI,EAAE,MAAM,CAAC;QACb,sCAAsC;QACtC,OAAO,EAAE,MAAM,CAAC;QAChB,yDAAyD;QACzD,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAexD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAmBtF"}