oh-my-opencode 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/hooks/codegraph-bootstrap/command-runner.d.ts

@@ -1,17 +0,0 @@
-export interface CodegraphCommandResult {
-    readonly exitCode: number;
-    readonly stderr?: string;
-    readonly stdout: string;
-    readonly timedOut: boolean;
-}
-export interface RunCodegraphCommandOptions {
-    readonly env: Record<string, string>;
-    readonly timeoutSignal?: AbortSignal;
-    readonly timeoutMs: number;
-}
-export interface CodegraphCommandInvocation {
-    readonly args: readonly string[];
-    readonly command: string;
-}
-export declare function runCodegraphCommand(projectRoot: string, command: string, args: readonly string[], options: RunCodegraphCommandOptions): Promise<CodegraphCommandResult>;
-export declare function resolveCodegraphCommandInvocation(command: string, args: readonly string[], platform?: NodeJS.Platform): CodegraphCommandInvocation;

package/dist/hooks/codegraph-bootstrap/hook.d.ts

@@ -1,35 +0,0 @@
-import { CODEGRAPH_PINNED_VERSION, type BuildCodegraphEnvOptions, type CodegraphCommandResolution, type CodegraphProjectExclusionDecision, type CodegraphProjectExclusionOptions, type CodegraphNodeSupport, type CodegraphProvisionResult, type CodegraphWorkspacePreparation, type PrepareCodegraphWorkspaceOptions, type ResolveCodegraphCommandOptions } from "@oh-my-opencode/utils";
-import type { CodegraphConfig } from "../../config";
-import type { CodegraphCommandResult } from "./command-runner";
-export interface CodegraphBootstrapContext {
-    readonly directory: string;
-}
-export interface CodegraphBootstrapEventInput {
-    readonly event: {
-        readonly properties?: unknown;
-        readonly type: string;
-    };
-}
-export interface CodegraphBootstrapDeps {
-    readonly buildEnv: (options?: BuildCodegraphEnvOptions) => Record<string, string>;
-    readonly ensureGitignored: (projectRoot: string) => boolean;
-    readonly excludeProject: (projectRoot: string, options?: CodegraphProjectExclusionOptions) => CodegraphProjectExclusionDecision;
-    readonly ensureProvisioned: (options: {
-        readonly installDir?: string;
-        readonly lockDir: string;
-        readonly version: typeof CODEGRAPH_PINNED_VERSION;
-    }) => Promise<CodegraphProvisionResult>;
-    readonly log: (message: string, data?: Record<string, unknown>) => void;
-    readonly nodeSupport: () => CodegraphNodeSupport;
-    readonly prepareWorkspace: (projectRoot: string, options?: PrepareCodegraphWorkspaceOptions) => CodegraphWorkspacePreparation;
-    readonly resolveCommand: (options?: ResolveCodegraphCommandOptions) => CodegraphCommandResolution;
-    readonly runCommand: (projectRoot: string, command: string, args: readonly string[], options: {
-        readonly env: Record<string, string>;
-        readonly timeoutMs: number;
-    }) => Promise<CodegraphCommandResult>;
-    readonly schedule: (task: () => Promise<void>) => void;
-}
-export declare function clearCodegraphBootstrapProjectsForTesting(): void;
-export declare function createCodegraphBootstrapHook(ctx: CodegraphBootstrapContext, config: Partial<CodegraphConfig> | undefined, depsOverride?: Partial<CodegraphBootstrapDeps>): {
-    event(input: CodegraphBootstrapEventInput): void;
-};

package/dist/hooks/codegraph-bootstrap/index.d.ts

@@ -1 +0,0 @@
-export { clearCodegraphBootstrapProjectsForTesting, createCodegraphBootstrapHook, type CodegraphBootstrapContext, type CodegraphBootstrapDeps, type CodegraphBootstrapEventInput, } from "./hook";

package/dist/hooks/codegraph-bootstrap/project-root.d.ts

@@ -1 +0,0 @@
-export declare function resolveCodegraphProjectRoot(properties: unknown, fallbackDirectory: string): string;

package/dist/hooks/codegraph-bootstrap/status.d.ts

@@ -1,11 +0,0 @@
-import type { CodegraphCommandResult } from "./command-runner";
-type CodegraphStatusDecision = {
-    readonly kind: "init";
-} | {
-    readonly kind: "skip";
-    readonly reason: string;
-} | {
-    readonly kind: "sync";
-};
-export declare function decideCodegraphStartupAction(status: CodegraphCommandResult): CodegraphStatusDecision;
-export {};

package/dist/hooks/ralph-loop/completion-promise-detector-test-input.d.ts

@@ -1,11 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export type SessionMessage = {
-    info?: {
-        role?: string;
-    };
-    parts?: Array<{
-        type: string;
-        text?: string;
-    }>;
-};
-export declare function createPluginInput(messages: SessionMessage[]): PluginInput;

package/dist/hooks/ralph-loop/loop-session-recovery.d.ts

@@ -1,7 +0,0 @@
-export declare function createLoopSessionRecovery(options?: {
-    recoveryWindowMs?: number;
-}): {
-    isRecovering(sessionID: string): boolean;
-    markRecovering(sessionID: string): void;
-    clear(sessionID: string): void;
-};

package/dist/hooks/start-work/start-work-hook.d.ts

@@ -1,23 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare const HOOK_NAME: "start-work";
-interface StartWorkHookInput {
-    sessionID: string;
-    messageID?: string;
-}
-interface StartWorkCommandExecuteBeforeInput {
-    sessionID: string;
-    command: string;
-    arguments: string;
-}
-interface StartWorkHookOutput {
-    message?: Record<string, unknown>;
-    parts: Array<{
-        type: string;
-        text?: string;
-    }>;
-}
-export declare function createStartWorkHook(ctx: PluginInput): {
-    "chat.message": (input: StartWorkHookInput, output: StartWorkHookOutput) => Promise<void>;
-    "command.execute.before": (input: StartWorkCommandExecuteBeforeInput, output: StartWorkHookOutput) => Promise<void>;
-};
-export {};

package/dist/mcp/codegraph.d.ts

@@ -1,16 +0,0 @@
-import type { ResolveCodegraphCommandOptions } from "@oh-my-opencode/utils";
-import type { CodegraphConfig } from "../config/schema/codegraph";
-import type { LocalMcpConfig } from "./lsp";
-import { type RuntimeExecutableResolver } from "./runtime-executable";
-export type CodegraphMcpConfigOptions = {
-    readonly config?: Partial<CodegraphConfig>;
-    readonly cwd?: string;
-    readonly env?: ResolveCodegraphCommandOptions["env"];
-    readonly fileExists?: ResolveCodegraphCommandOptions["fileExists"];
-    readonly homeDir?: string;
-    readonly nodeVersionForExecutable?: ResolveCodegraphCommandOptions["nodeVersion"];
-    readonly provisioned?: ResolveCodegraphCommandOptions["provisioned"];
-    readonly requireResolve?: ResolveCodegraphCommandOptions["requireResolve"];
-    readonly resolveExecutable?: RuntimeExecutableResolver;
-};
-export declare function createCodegraphMcpConfig(options?: CodegraphMcpConfigOptions): LocalMcpConfig;

package/dist/plugin/chat-message/start-work-message.d.ts

@@ -1,5 +0,0 @@
-import type { ChatMessageHooks, ChatMessageInput, ChatMessageHandlerOutput, StartWorkHookOutput, WorkStartingCommand } from "./types";
-export declare function isStartWorkHookOutput(value: unknown): value is StartWorkHookOutput;
-export declare function isStartWorkFallbackTemplate(promptText: string): boolean;
-export declare function clearStoppedContinuationBeforeWorkStart(hooks: ChatMessageHooks, sessionID: string, command: WorkStartingCommand): void;
-export declare function runStartWorkHookIfApplicable(hooks: ChatMessageHooks, input: ChatMessageInput, output: ChatMessageHandlerOutput): Promise<void>;

package/dist/shared/prompt-async-gate/message-inspection-error.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/message-inspection-error";

package/dist/shared/prompt-async-gate/pending-tool-turn.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/pending-tool-turn";

package/dist/shared/prompt-async-gate/prompt-message-state.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/prompt-message-state";

package/dist/shared/prompt-async-gate/queue.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/queue";

package/dist/shared/prompt-async-gate/recent-dispatches.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/recent-dispatches";

package/dist/shared/prompt-async-gate/reservations.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/reservations";

package/dist/shared/prompt-async-gate/semantic-dedupe.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/semantic-dedupe";

package/dist/shared/prompt-async-gate/session-idle-dispatch.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/session-idle-dispatch";

package/dist/shared/prompt-async-gate/timing.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/timing";

package/dist/shared/prompt-async-gate/types.d.ts

@@ -1 +0,0 @@
-export * from "@oh-my-opencode/utils/prompt-async-gate/types";

package/dist/skills/data-scientist/references/common-scenarios.md

@@ -1,176 +0,0 @@
-# Common Scenarios with Tool Selection
-
-## Scenario 1: Simple Calculation
-
-**Decision: Python (always)**
-
-```python
-uv run --with numpy python -c "
-import numpy as np
-result = np.sum([1, 2, 3, 4, 5])
-print(f'Result: {result}')
-"
-```
-
-## Scenario 2: CSV Quick Analysis
-
-**Decision: DuckDB (direct query, no memory load)**
-
-```python
-uv run --with numpy --with duckdb python -c "
-import duckdb
-result = duckdb.sql('''
-    SELECT * FROM 'data.csv'
-    LIMIT 10
-''').pl()
-print(result)
-"
-```
-
-## Scenario 3: Filter + Sort on Large Dataset
-
-**Decision: Polars (128x faster filtering, 12x faster sorting)**
-
-```python
-uv run --with numpy --with polars python -c "
-import polars as pl
-result = (
-    pl.scan_csv('large.csv')
-    .filter(pl.col('value') > 1000)
-    .sort('value', descending=True)
-    .head(100)
-    .collect()
-)
-print(result)
-"
-```
-
-## Scenario 4: Multi-Table Join + Aggregation
-
-**Decision: DuckDB (best for joins and aggregations)**
-
-```python
-uv run --with numpy --with duckdb python -c "
-import duckdb
-result = duckdb.sql('''
-    SELECT
-        a.category,
-        COUNT(*) as count,
-        SUM(b.amount) as total
-    FROM 'table1.csv' a
-    JOIN 'table2.csv' b ON a.id = b.id
-    GROUP BY a.category
-    ORDER BY total DESC
-''').pl()
-print(result)
-"
-```
-
-## Scenario 5: Data Exploration
-
-**Decision: DuckDB for quick exploration**
-
-```python
-uv run --with numpy --with duckdb python -c "
-import duckdb
-
-# Show first few rows
-print('**Sample Data**')
-print(duckdb.sql('SELECT * FROM \"data.csv\" LIMIT 5').pl())
-
-# Show summary statistics
-print('\\n**Summary Statistics**')
-print(duckdb.sql('DESCRIBE SELECT * FROM \"data.csv\"').pl())
-
-# Show row count
-print('\\n**Row Count**')
-print(duckdb.sql('SELECT COUNT(*) as total_rows FROM \"data.csv\"').pl())
-"
-```
-
-## Scenario 6: Time-Series Analysis
-
-**Decision: DuckDB for aggregation + matplotlib for visualization**
-
-```python
-uv run --with numpy --with duckdb --with pyarrow --with matplotlib python -c "
-import duckdb
-import matplotlib.pyplot as plt
-
-# Aggregate by date
-result = duckdb.sql('''
-    SELECT
-        DATE_TRUNC('day', timestamp) as date,
-        COUNT(*) as count,
-        AVG(value) as avg_value
-    FROM 'timeseries.csv'
-    GROUP BY date
-    ORDER BY date
-''').pl()
-
-# Plot
-plt.figure(figsize=(12, 6))
-plt.subplot(2, 1, 1)
-plt.plot(result['date'], result['count'])
-plt.title('Daily Count')
-
-plt.subplot(2, 1, 2)
-plt.plot(result['date'], result['avg_value'])
-plt.title('Daily Average Value')
-
-plt.tight_layout()
-plt.savefig('timeseries.png')
-print('Saved to timeseries.png')
-"
-```
-
-## Scenario 7: Complex Transformation
-
-**Decision: Polars for efficient transformations**
-
-```python
-uv run --with numpy --with polars python -c "
-import polars as pl
-
-result = (
-    pl.scan_csv('data.csv')
-    .with_columns([
-        # Create new calculated columns
-        (pl.col('price') * pl.col('quantity')).alias('total'),
-        pl.col('date').str.strptime(pl.Date, '%Y-%m-%d').alias('parsed_date'),
-        pl.col('name').str.to_uppercase().alias('upper_name'),
-    ])
-    .filter(pl.col('total') > 100)
-    .select(['parsed_date', 'upper_name', 'total'])
-    .collect()
-)
-
-print(result)
-"
-```
-
-## Scenario 8: Large File Processing
-
-**Decision: Polars streaming mode**
-
-```python
-uv run --with numpy --with polars python -c "
-import polars as pl
-
-# Process file larger than RAM
-result = (
-    pl.scan_csv('huge_file.csv')
-    .filter(pl.col('active') == True)
-    .groupby('category')
-    .agg([
-        pl.count().alias('count'),
-        pl.sum('amount').alias('total'),
-        pl.mean('amount').alias('average'),
-    ])
-    .collect(streaming=True)  # Streaming mode
-)
-
-print(result)
-print(f'\\nProcessed {result[\"count\"].sum():,} rows')
-"
-```

package/dist/skills/data-scientist/references/execution-templates.md

@@ -1,197 +0,0 @@
-# Execution Templates
-
-## Template 1: DuckDB for Simple/Complex SQL Queries
-
-**Use when:**
-- Simple aggregation on single file
-- Complex multi-table joins
-- Heavy GROUP BY operations
-- Window functions with complex SQL logic
-- Ad-hoc exploration queries
-
-```python
-uv run --with numpy --with duckdb python -c "
-import duckdb
-
-# Simple query - direct file access
-result = duckdb.sql('''
-    SELECT
-        category,
-        COUNT(*) as count,
-        AVG(amount) as avg_amount,
-        SUM(amount) as total
-    FROM 'data.csv'
-    WHERE date >= '2024-01-01'
-    GROUP BY category
-    ORDER BY total DESC
-    LIMIT 10
-''').pl()
-
-print('**Results**')
-print(result)
-print(f'\\nProcessed {len(result)} categories')
-"
-```
-
-## Template 2: Polars for Filtering & Sorting
-
-**Use when:**
-- Primary operation is filtering large dataset
-- Sorting required
-- Chain transformations
-- Memory-efficient processing needed
-
-```python
-uv run --with numpy --with polars python -c "
-import polars as pl
-
-# Lazy evaluation for optimal performance
-result = (
-    pl.scan_csv('data.csv')  # Lazy scan
-    .filter(
-        (pl.col('amount') > 1000) &
-        (pl.col('status') == 'active') &
-        (pl.col('date') >= '2024-01-01')
-    )
-    .sort('amount', descending=True)
-    .head(100)
-    .collect()  # Execute optimized plan
-)
-
-print('**Filtered and Sorted Results**')
-print(result)
-print(f'\\nFound {len(result)} matching rows')
-"
-```
-
-## Template 3: Hybrid Approach (Best of Both)
-
-**Use when:**
-- Need joins AND heavy filtering
-- Complex SQL followed by transformations
-- Optimize different operation stages
-
-```python
-uv run --with numpy --with duckdb --with polars --with pyarrow python -c "
-import duckdb
-import polars as pl
-
-print('Phase 1: DuckDB for complex join (3x faster)')
-# DuckDB excels at joins
-joined = duckdb.sql('''
-    SELECT
-        o.order_id,
-        o.amount,
-        c.customer_id,
-        c.region,
-        p.category
-    FROM 'orders.csv' o
-    JOIN 'customers.csv' c ON o.customer_id = c.customer_id
-    JOIN 'products.csv' p ON o.product_id = p.product_id
-    WHERE o.date >= '2024-01-01'
-''').pl()  # Convert to Polars
-
-print(f'Joined {len(joined):,} rows')
-
-print('\\nPhase 2: Polars for ultra-fast filtering (128x faster)')
-# Polars excels at filtering
-filtered = (
-    joined
-    .filter(
-        (pl.col('amount') > 100) &
-        (pl.col('region').is_in(['North', 'South', 'East']))
-    )
-    .with_columns([
-        (pl.col('amount') * 1.1).alias('amount_with_tax')
-    ])
-)
-
-print(f'Filtered to {len(filtered):,} rows')
-
-print('\\nPhase 3: DuckDB for final aggregation (4x faster)')
-# Back to DuckDB for aggregation
-duckdb.register('filtered_data', filtered)
-final = duckdb.sql('''
-    SELECT
-        region,
-        category,
-        COUNT(DISTINCT customer_id) as customers,
-        SUM(amount_with_tax) as total_revenue,
-        AVG(amount_with_tax) as avg_transaction
-    FROM filtered_data
-    GROUP BY region, category
-    HAVING total_revenue > 10000
-    ORDER BY total_revenue DESC
-''').pl()
-
-print('\\n**Final Results**')
-print(final)
-"
-```
-
-## Template 4: Polars Streaming for Large Files
-
-**Use when:**
-- Dataset larger than available RAM
-- Need to process data in batches
-- Memory constraints
-
-```python
-uv run --with numpy --with polars python -c "
-import polars as pl
-
-# Streaming mode - processes data in chunks
-result = (
-    pl.scan_csv('huge_file.csv')
-    .filter(pl.col('status') == 'active')
-    .with_columns([
-        (pl.col('amount') * 1.1).alias('adjusted_amount')
-    ])
-    .groupby('category')
-    .agg([
-        pl.sum('adjusted_amount').alias('total'),
-        pl.count().alias('count')
-    ])
-    .collect(streaming=True)  # Streaming mode for large data
-)
-
-print('**Streaming Results**')
-print(result)
-print(f'\\nProcessed {result[\"count\"].sum():,} total rows')
-"
-```
-
-## Template 5: Visualization with Matplotlib
-
-**Use when:**
-- User requests charts, graphs, or plots
-- Exploratory data analysis (EDA)
-- Time-series or distribution analysis
-
-```python
-uv run --with numpy --with duckdb --with polars --with pyarrow --with matplotlib python -c "
-import duckdb
-import matplotlib.pyplot as plt
-
-# Query data
-result = duckdb.sql('''
-    SELECT
-        date,
-        SUM(amount) as total
-    FROM 'data.csv'
-    GROUP BY date
-    ORDER BY date
-''').pl()
-
-# Create visualization
-plt.figure(figsize=(10, 6))
-plt.plot(result['date'], result['total'])
-plt.xlabel('Date')
-plt.ylabel('Total Amount')
-plt.title('Daily Total Trends')
-plt.xticks(rotation=45)
-plt.tight_layout()
-plt.savefig('output.png')
-print('Chart saved to output.png')
-"
-```