oh-my-opencode 5.0.0-beta.4 → 5.0.0-beta.40

package/packages/omo-codex/plugin/skills/data-scientist/references/integration-patterns.md

@@ -1,153 +0,0 @@
-# Integration Patterns: DuckDB ↔ Polars
-
-## Zero-Copy Conversions (FASTEST)
-
-### DuckDB → Polars (Recommended)
-
-```python
-import duckdb
-import polars as pl
-
-# Direct conversion with .pl() - zero-copy via Arrow
-df_polars = duckdb.sql("""
-    SELECT * FROM 'data.parquet'
-    WHERE amount > 100
-""").pl()  # Returns Polars DataFrame directly
-
-# Lazy version for large datasets
-lazy_df = duckdb.sql("SELECT * FROM 'data.parquet'").pl(lazy=True)
-result = lazy_df.filter(pl.col('status') == 'active').collect()
-```
-
-### Polars → DuckDB (Direct Reference)
-
-```python
-import duckdb
-import polars as pl
-
-# DuckDB can query Polars DataFrames directly by name
-df = pl.read_parquet('data.parquet')
-
-result = duckdb.sql("""
-    SELECT category, SUM(amount) as total
-    FROM df
-    GROUP BY category
-    ORDER BY total DESC
-""").pl()  # Query df directly, return as Polars
-```
-
-### Via Arrow (When Needed)
-
-```python
-# Polars → Arrow → DuckDB
-df_polars = pl.read_csv('data.csv')
-duckdb.register('my_table', df_polars.to_arrow())
-
-# DuckDB → Arrow → Polars
-arrow_table = duckdb.sql("SELECT * FROM data").arrow()
-df_polars = pl.from_arrow(arrow_table)
-```
-
-## WRONG vs RIGHT Patterns
-
-### ❌ NEVER - Using Pandas
-
-```python
-# FORBIDDEN - decisively slower than Polars/DuckDB on every operation!
-import pandas as pd
-df = pd.read_csv('data.csv')
-result = df.groupby('category')['amount'].sum()
-```
-
-### ✅ CORRECT - DuckDB for simple aggregation query
-
-```python
-import duckdb
-# Direct file query - no memory loading!
-result = duckdb.sql("""
-    SELECT category, SUM(amount) as total
-    FROM 'data.csv'
-    GROUP BY category
-""").pl()  # Fast, memory-efficient
-```
-
-### ❌ NEVER - Loading file before DuckDB query
-
-```python
-# WRONG - Unnecessary memory usage
-import polars as pl
-import duckdb
-df = pl.read_csv('data.csv')  # Loads entire file
-result = duckdb.sql("SELECT * FROM df WHERE amount > 100").pl()
-```
-
-### ✅ CORRECT - Let DuckDB query directly
-
-```python
-import duckdb
-# DuckDB queries file directly - much faster!
-result = duckdb.sql("""
-    SELECT * FROM 'data.csv'
-    WHERE amount > 100
-""").pl()
-```
-
-### ❌ NEVER - Eager evaluation in Polars
-
-```python
-# WRONG - Loads everything immediately
-import polars as pl
-df = pl.read_csv('large_data.csv')  # Eager load
-filtered = df.filter(pl.col('value') > 100)
-```
-
-### ✅ CORRECT - Lazy evaluation
-
-```python
-import polars as pl
-# Lazy - builds query plan, optimizes, executes once
-df = pl.scan_csv('large_data.csv')  # Lazy
-result = (
-    df
-    .filter(pl.col('value') > 100)
-    .groupby('category')
-    .agg(pl.sum('value'))
-    .collect()  # Execute optimized plan
-)
-```
-
-### ❌ NEVER - Unnecessary Conversions
-
-```python
-# WASTEFUL (DuckDB → Pandas → Polars)
-import duckdb, pandas as pd, polars as pl
-df_pd = duckdb.sql("SELECT * FROM 'data.csv'").df()  # requires pandas - the skill never ships it
-df_pl = pl.from_pandas(df_pd)
-```
-
-### ✅ CORRECT - Direct conversion
-
-```python
-# DIRECT (DuckDB → Polars via Arrow)
-import duckdb
-df_pl = duckdb.sql("SELECT * FROM 'data.csv'").pl()
-```
-
-### ❌ NEVER - Wrong tool for heavy filtering
-
-```python
-# SLOW (DuckDB not optimal for filtering)
-import duckdb
-result = duckdb.sql("""
-    SELECT * FROM 'huge.csv'
-    WHERE complex_filter = true
-""").pl()
-```
-
-### ✅ CORRECT - Use Polars for filtering
-
-```python
-# FAST (Polars 128x faster for filtering)
-import polars as pl
-result = pl.scan_csv('huge.csv').filter(pl.col('complex_filter')).collect()
-```

package/packages/omo-codex/plugin/skills/data-scientist/references/performance-benchmarks.md

@@ -1,37 +0,0 @@
-# Performance Benchmarks
-
-Routing heuristics distilled from public 2024-2025 results in the [db-benchmark suite](https://github.com/h2oai/db-benchmark) (rendered at [h2oai.github.io/db-benchmark](https://h2oai.github.io/db-benchmark/)) and from the vendors' own documentation ([duckdb.org](https://duckdb.org/), [pola.rs](https://pola.rs/)).
-
-**Read these as routing guidance, not guarantees.** Multipliers vary with dataset size, cardinality, data types, and hardware. When the choice materially matters, measure on the actual data.
-
-## Operation Performance Comparison
-
-| Operation Type      | Winner      | Indicative advantage | When to Use                                    |
-|---------------------|-------------|----------------------|------------------------------------------------|
-| **Filtering**       | **Polars**  | often the fastest by a wide margin (SIMD, predicate pushdown) | Single-table filters |
-| **Sorting**         | **Polars**  | typically the fastest | ORDER BY operations, ranking                   |
-| **Joins**           | **DuckDB**  | typically faster; richer join types | Multi-table joins, especially complex joins    |
-| **Aggregations**    | **DuckDB**  | typically faster on large datasets | GROUP BY, complex aggregations                 |
-| **Window Funcs**    | **Polars**  | typically faster | RANK, LAG/LEAD, running totals                 |
-| **Transformations** | **Polars**  | typically faster | Pivot, melt, string operations                 |
-| **Direct Query**    | **DuckDB**  | avoids loading to memory entirely | Ad-hoc exploration without loading to memory   |
-| **Streaming**       | **Polars**  | handles datasets larger than RAM | Datasets larger than RAM                       |
-
-Both tools are decisively faster than pandas on 1M+ row workloads, which is why pandas is banned outright in this skill.
-
-## Operation Detection Keywords
-
-Automatically detect operation types from user requests:
-
-- **Filter**: "where", "filter", "condition", "select rows", "find"
-- **Sort**: "sort", "order", "top", "bottom", "rank"
-- **Join**: "join", "merge", "combine tables"
-- **Aggregate**: "group", "sum", "avg", "count", "mean", "total", "aggregate"
-- **Transform**: "pivot", "melt", "reshape", "string operations", "clean", "transform"
-- **Window**: "running", "cumulative", "lag", "lead", "rank", "partition"
-
-## Benchmarking Notes
-
-- Public suites exercise typical analytical workloads (1M-100M rows).
-- Performance advantages are approximate and vary by dataset characteristics.
-- Real-world performance depends on data types, cardinality, and hardware.

package/packages/omo-codex/plugin/skills/start-work/agents/openai.yaml

@@ -1,2 +0,0 @@
-interface:
-  display_name: "(OmO) start-work"

package/packages/omo-codex/plugin/test/aggregate-skills.test.mjs

@@ -1,92 +0,0 @@
-import assert from "node:assert/strict";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import test from "node:test";
-
-import {
-	findInvalidSpawnAgentRoleParameters,
-	findSpawnAgentCallsWithoutForkContextFalse,
-	root,
-} from "./aggregate-plugin-fixture.mjs";
-import { listSkillFiles } from "./sync-skills-test-support.mjs";
-
-test("#given synced skills with Codex compatibility guidance #when spawn_agent is documented #then invalid role parameters are absent", async () => {
-	const skillsDir = join(root, "skills");
-	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
-	const skillFiles = skillEntries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
-
-	const invalidCalls = [];
-	for (const skillPath of skillFiles) {
-		const content = await readFile(skillPath, "utf8");
-		for (const call of findInvalidSpawnAgentRoleParameters(content)) {
-			invalidCalls.push(`${basename(dirname(skillPath))}/${basename(skillPath)}: ${call}`);
-		}
-	}
-
-	assert.deepEqual(invalidCalls, []);
-});
-
-test('#given synced skills and bundled rules #when role-specific agents are spawned #then they set fork_context=false', async () => {
-	const skillsDir = join(root, "skills");
-	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
-	const promptFiles = skillEntries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
-	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.5.md"));
-	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.6.md"));
-
-	const missingForkContext = [];
-	for (const promptPath of promptFiles) {
-		const content = await readFile(promptPath, "utf8");
-		for (const call of findSpawnAgentCallsWithoutForkContextFalse(content)) {
-			missingForkContext.push(`${basename(dirname(promptPath))}/${basename(promptPath)}: ${call}`);
-		}
-	}
-
-	assert.deepEqual(missingForkContext, []);
-});
-
-test("#given long-running orchestration prompts #when waiting on child agents #then parent liveness is surfaced", async () => {
-	const promptFiles = [
-		join(root, "skills", "ulw-loop", "SKILL.md"),
-		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
-		join(root, "skills", "review-work", "SKILL.md"),
-		join(root, "skills", "start-work", "SKILL.md"),
-		join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.5.md"),
-		join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.6.md"),
-	];
-
-	const missingLivenessGuidance = [];
-	for (const promptPath of promptFiles) {
-		const content = await readFile(promptPath, "utf8");
-		if (!/active\s+subagent count/.test(content) || !/latest `WORKING:` phase/.test(content)) {
-			missingLivenessGuidance.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
-		}
-	}
-
-	assert.deepEqual(missingLivenessGuidance, []);
-});
-
-test("#given packaged Codex prompt surfaces #when inspected #then removed sparkshell guidance is absent", async () => {
-	const promptRoots = [
-		join(root, "skills"),
-		join(root, "components", "rules", "bundled-rules"),
-		join(root, "components", "ultrawork", "agents"),
-		join(root, "components", "ulw-loop", "skills"),
-	];
-	const promptFilePattern = /\.(?:json|md|toml|ya?ml)$/i;
-	const removedSparkshellPattern = /\b(?:sparkshell|spark[-_\s]+shell)\b/i;
-	const matches = [];
-
-	for (const promptRoot of promptRoots) {
-		for (const relativePath of await listSkillFiles(promptRoot)) {
-			if (!promptFilePattern.test(relativePath)) continue;
-			const content = await readFile(join(promptRoot, relativePath), "utf8");
-			if (removedSparkshellPattern.test(content)) matches.push(`${promptRoot}/${relativePath}`);
-		}
-	}
-
-	assert.deepEqual(matches, []);
-});

package/packages/omo-codex/plugin/test/component-codegraph-mcp-smoke.test.mjs

@@ -1,76 +0,0 @@
-import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import test from "node:test";
-
-import { root } from "./aggregate-plugin-fixture.mjs";
-
-const MCP_SMOKE_TIMEOUT_MS = 45_000;
-
-test("#given built CodeGraph MCP wrapper #when an MCP client initializes #then the resolved child responds over stdio", () => {
-	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-codegraph-mcp-smoke-"));
-	try {
-		const fakeBinaryPath = join(tempRoot, "codegraph-fake.cjs");
-		writeFileSync(
-			fakeBinaryPath,
-			[
-				"#!/usr/bin/env node",
-				"const readline = require('node:readline');",
-				"const rl = readline.createInterface({ input: process.stdin });",
-				"rl.on('line', (line) => {",
-				"  const request = JSON.parse(line);",
-				"  if (request.method !== 'initialize') return;",
-				"  process.stdout.write(JSON.stringify({",
-				"    jsonrpc: '2.0',",
-				"    id: request.id,",
-				"    result: {",
-				"      protocolVersion: request.params?.protocolVersion ?? '2024-11-05',",
-				"      capabilities: { tools: { listChanged: false } },",
-				"      serverInfo: { name: 'fake-codegraph', version: '0.0.0' }",
-				"    }",
-				"  }) + '\\n');",
-				"});",
-				"",
-			].join("\n"),
-		);
-		chmodSync(fakeBinaryPath, 0o755);
-
-		const result = spawnSync(process.execPath, [join(root, "components", "codegraph", "dist", "serve.js")], {
-			cwd: root,
-			encoding: "utf8",
-			env: {
-				...process.env,
-				HOME: tempRoot,
-				OMO_CODEGRAPH_BIN: fakeBinaryPath,
-			},
-			input: `${JSON.stringify({
-				jsonrpc: "2.0",
-				id: 1,
-				method: "initialize",
-				params: {
-					capabilities: {},
-					clientInfo: { name: "lazycodex-smoke", version: "0.0.0" },
-					protocolVersion: "2024-11-05",
-				},
-			})}\n`,
-			timeout: MCP_SMOKE_TIMEOUT_MS,
-		});
-
-		assert.equal(result.status, 0, `stderr: ${result.stderr}`);
-		assert.equal(result.stderr, "");
-		const response = JSON.parse(result.stdout.trim());
-		assert.deepEqual(response, {
-			jsonrpc: "2.0",
-			id: 1,
-			result: {
-				capabilities: { tools: { listChanged: false } },
-				protocolVersion: "2024-11-05",
-				serverInfo: { name: "fake-codegraph", version: "0.0.0" },
-			},
-		});
-	} finally {
-		rmSync(tempRoot, { recursive: true, force: true });
-	}
-});

package/packages/omo-codex/plugin/test/migrate-omo-sot.test.mjs

@@ -1,179 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import { migrateOmoSotConfig } from "../scripts/migrate-omo-sot.mjs";
-
-test("#given no OMO SOT #when seeding #then creates a parseable scaffold once", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-seed-"));
-
-	const first = await migrateOmoSotConfig({ env: { HOME: home }, seed: true });
-	const before = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
-	const second = await migrateOmoSotConfig({ env: { HOME: home }, seed: true });
-	const after = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
-
-	assert.equal(first.seeded, true);
-	assert.equal(second.seeded, false);
-	assert.equal(after, before);
-	assert.equal(parseJsonc(after)["[codex]"].codegraph.enabled, undefined);
-	assert.equal(parseJsonc(after).codegraph.enabled, undefined);
-	assert.match(after, /"enabled"/);
-	assert.match(after, /"\[opencode\]"/);
-});
-
-test("#given no OMO SOT and legacy CodeGraph env #when seeding #then creates scaffold with Codex scoped migration", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-seed-env-"));
-
-	await migrateOmoSotConfig({
-		env: {
-			HOME: home,
-			CODEX_CODEGRAPH_AUTO_PROVISION: "yes",
-			CODEX_CODEGRAPH_ENABLED: "1",
-			OMO_CODEGRAPH_INSTALL_DIR: "/tmp/codegraph",
-			OMO_CODEGRAPH_TELEMETRY: "false",
-		},
-		seed: true,
-	});
-
-	const content = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
-	const parsed = parseJsonc(content);
-	assert.equal(parsed.codegraph.enabled, undefined);
-	assert.deepEqual(parsed["[codex]"].codegraph, {
-		auto_provision: true,
-		enabled: true,
-		install_dir: "/tmp/codegraph",
-		telemetry: false,
-	});
-	assert.match(content, /Shared OMO settings/);
-	assert.match(content, /"\[opencode\]"/);
-});
-
-test("#given legacy CodeGraph env #when migrating #then adds Codex scoped codegraph values", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-env-"));
-	await mkdir(join(home, ".omo"), { recursive: true });
-	await writeFile(join(home, ".omo", "config.jsonc"), "{\n}\n");
-
-	const result = await migrateOmoSotConfig({
-		env: {
-			HOME: home,
-			CODEX_CODEGRAPH_AUTO_PROVISION: "0",
-			CODEX_CODEGRAPH_ENABLED: "false",
-			OMO_CODEGRAPH_INSTALL_DIR: "/tmp/codegraph",
-			OMO_CODEGRAPH_TELEMETRY: "1",
-		},
-		seed: true,
-	});
-
-	const parsed = parseJsonc(await readFile(join(home, ".omo", "config.jsonc"), "utf8"));
-	assert.equal(result.changed, true);
-	assert.deepEqual(parsed["[codex]"].codegraph, {
-		auto_provision: false,
-		enabled: false,
-		install_dir: "/tmp/codegraph",
-		telemetry: true,
-	});
-});
-
-test("#given existing user SOT #when migrating env #then preserves user values and comments", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-preserve-"));
-	const configPath = join(home, ".omo", "config.jsonc");
-	await mkdir(join(home, ".omo"), { recursive: true });
-	await writeFile(
-		configPath,
-		[
-			"{",
-			"  // keep my debounce",
-			'  "codegraph": {',
-			"    \"watch_debounce_ms\": 4242",
-			"  }",
-			"}",
-			"",
-		].join("\n"),
-	);
-
-	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
-
-	const content = await readFile(configPath, "utf8");
-	const parsed = parseJsonc(content);
-	assert.match(content, /keep my debounce/);
-	assert.equal(parsed.codegraph.watch_debounce_ms, 4242);
-	assert.equal(parsed["[codex]"].codegraph.enabled, false);
-});
-
-test("#given existing Codex scoped SOT #when migrating env #then user value wins", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-user-wins-"));
-	const configPath = join(home, ".omo", "config.jsonc");
-	await mkdir(join(home, ".omo"), { recursive: true });
-	await writeFile(configPath, '{\n  "[codex]": { "codegraph": { "enabled": true } }\n}\n');
-
-	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
-
-	const parsed = parseJsonc(await readFile(configPath, "utf8"));
-	assert.equal(parsed["[codex]"].codegraph.enabled, true);
-});
-
-test("#given opencode scoped SOT #when migrating env #then opencode block is not changed", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-opencode-"));
-	const configPath = join(home, ".omo", "config.jsonc");
-	await mkdir(join(home, ".omo"), { recursive: true });
-	await writeFile(configPath, '{\n  "[opencode]": { "codegraph": { "enabled": true } }\n}\n');
-
-	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
-
-	const parsed = parseJsonc(await readFile(configPath, "utf8"));
-	assert.equal(parsed["[opencode]"].codegraph.enabled, true);
-	assert.equal(parsed["[codex]"].codegraph.enabled, false);
-});
-
-test("#given malformed existing SOT #when migrating #then leaves it untouched and warns", async () => {
-	const home = await mkdtemp(join(tmpdir(), "omo-sot-malformed-"));
-	const configPath = join(home, ".omo", "config.jsonc");
-	await mkdir(join(home, ".omo"), { recursive: true });
-	await writeFile(configPath, '{ "codegraph":');
-
-	const result = await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
-
-	assert.equal(await readFile(configPath, "utf8"), '{ "codegraph":');
-	assert.equal(result.changed, false);
-	assert.equal(result.seeded, false);
-	assert.match(result.warnings.join("\n"), /Could not parse/);
-});
-
-function parseJsonc(content) {
-	return JSON.parse(stripTrailingCommas(stripJsonComments(content)));
-}
-
-function stripJsonComments(content) {
-	let result = "";
-	let inString = false;
-	let escape = false;
-	for (let index = 0; index < content.length; index += 1) {
-		const char = content[index];
-		const next = content[index + 1];
-		if (inString) {
-			result += char;
-			if (escape) escape = false;
-			else if (char === "\\") escape = true;
-			else if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			result += char;
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			while (index < content.length && content[index] !== "\n") index += 1;
-			result += "\n";
-			continue;
-		}
-		result += char;
-	}
-	return result;
-}
-
-function stripTrailingCommas(content) {
-	return content.replace(/,\s*([}\]])/g, "$1");
-}