oh-my-opencode 5.0.0-beta.9 → 5.0.0

package/dist/cli/install-codex/install-codex-test-fixtures.d.ts

@@ -15,7 +15,7 @@ export declare const EXPECTED_OMO_COMPONENT_BINS: readonly [{
     readonly name: "omo-rules";
     readonly target: string;
 }, {
-    readonly name: "omo-start-work-continuation";
+    readonly name: "omo-ulw-execute-continuation";
     readonly target: string;
 }, {
     readonly name: "omo-telemetry";

package/dist/cli/install-native/index.d.ts

@@ -0,0 +1,12 @@
+export { formatNativeInstallCommand, formatNativeInstallEntryCommand, NATIVE_PACKAGE_SPEC, NATIVE_RECOMMENDED_RUNTIME_NOTE, NATIVE_SETUP_COMMAND, resolveNativeInstallPlan, } from "./plan";
+export type { NativeInstallPlan, NativePackageManager } from "./plan";
+export { firstOmoBinOnPath, LEGACY_OMO_BIN_PACKAGES, legacyOmoBins, NATIVE_OMO_PACKAGE, nativeOmoBin, resolveOmoBinEnvironment, scanOmoBins, } from "./legacy-omo-bin";
+export type { OmoBinEntry, OmoBinEnvironment, OmoBinKind } from "./legacy-omo-bin";
+export { removeFileCommand, repairLegacyOmoBins } from "./repair-legacy-omo-bin";
+export type { LegacyOmoBinRepair } from "./repair-legacy-omo-bin";
+export { pathOrderFix, verifyOmoCommand } from "./verify-omo-command";
+export type { OmoCommandVerification, OmoVersionProbe } from "./verify-omo-command";
+export { nativeInstallFailureLines, nativeInstallSuccessLine, runNativeInstall, } from "./run-native-install";
+export { NATIVE_SETUP_OFFER_QUESTION, nativeSetupFollowUpLine, nativeSetupStartLine, offerNativeSetup, } from "./offer-native-setup";
+export type { NativeSetupOfferDependencies, NativeSetupOfferResult, NativeSetupRun } from "./offer-native-setup";
+export type { NativeInstallDependencies, NativeInstallFailure, NativeInstallOutcome, NativeInstallSpawn, NativeInstallSpawnResult, } from "./run-native-install";

package/dist/cli/install-native/legacy-omo-bin.d.ts

@@ -0,0 +1,27 @@
+export declare const NATIVE_OMO_PACKAGE = "omo-ai";
+export declare const LEGACY_OMO_BIN_PACKAGES: readonly string[];
+export type OmoBinKind = "native" | "legacy" | "foreign";
+export interface OmoBinEnvironment {
+    readonly pathDirectories: readonly string[];
+    readonly extraDirectories: readonly string[];
+    readonly isWindows: boolean;
+}
+export interface OmoBinEntry {
+    readonly binPath: string;
+    readonly directory: string;
+    readonly onPath: boolean;
+    readonly kind: OmoBinKind;
+    readonly packageName: string | null;
+    readonly packageVersion: string | null;
+    /** Every file that carries this `omo` command, including the Windows `.cmd` / `.ps1` siblings. */
+    readonly shimPaths: readonly string[];
+}
+export declare function resolveOmoBinEnvironment(input: {
+    readonly env: Record<string, string | undefined>;
+    readonly platform: string;
+    readonly homeDir: string;
+}): OmoBinEnvironment;
+export declare function scanOmoBins(environment: OmoBinEnvironment): readonly OmoBinEntry[];
+export declare function legacyOmoBins(entries: readonly OmoBinEntry[]): readonly OmoBinEntry[];
+export declare function nativeOmoBin(entries: readonly OmoBinEntry[]): OmoBinEntry | null;
+export declare function firstOmoBinOnPath(entries: readonly OmoBinEntry[]): OmoBinEntry | null;

package/dist/cli/install-native/offer-native-setup.d.ts

@@ -0,0 +1,31 @@
+import type { NativeInstallOutcome } from "./run-native-install";
+export declare const NATIVE_SETUP_OFFER_QUESTION = "Run omo setup now to carry your OpenCode credentials, MCP servers and skills over?";
+export type NativeSetupRun = (binPath: string, args: readonly string[]) => Promise<number>;
+export interface NativeSetupOfferDependencies {
+    readonly confirm: (question: string) => Promise<boolean>;
+    readonly runSetup?: NativeSetupRun;
+    /** Receives the start line right before the setup process takes over the terminal. */
+    readonly onStart?: (line: string) => void;
+}
+export type NativeSetupOfferResult = {
+    readonly kind: "not-offered";
+} | {
+    readonly kind: "declined";
+} | {
+    readonly kind: "ran";
+    readonly binPath: string;
+    readonly exitCode: number;
+} | {
+    readonly kind: "failed";
+    readonly binPath: string;
+    readonly reason: string;
+};
+/**
+ * Offers to run onboarding with the exact binary the install just verified. An unverified install
+ * is never offered: whatever `omo` PATH resolves there is, by definition, not omo-ai, and the PATH
+ * fix printed by the verify step stays the next thing to do.
+ */
+export declare function offerNativeSetup(outcome: Pick<NativeInstallOutcome, "verified" | "omoBinPath">, dependencies: NativeSetupOfferDependencies): Promise<NativeSetupOfferResult>;
+export declare function nativeSetupStartLine(binPath: string): string;
+/** The line to print after the offer, or null when the offer already finished onboarding. */
+export declare function nativeSetupFollowUpLine(result: NativeSetupOfferResult): string | null;

package/dist/cli/install-native/omo-bin-test-fixtures.d.ts

@@ -0,0 +1,35 @@
+export interface GlobalBinFixture {
+    readonly root: string;
+    readonly binDir: string;
+    readonly binPath: string;
+    readonly packageDir: string;
+}
+export interface GlobalBinFixtureOptions {
+    readonly root: string;
+    readonly packageName: string;
+    readonly version: string;
+    readonly bins?: readonly string[];
+    readonly link?: "symlink" | "script";
+}
+export declare function createBinFixtureRoot(label: string): string;
+/**
+ * Lays out a global install the way npm and bun really do it: the package under
+ * `lib/node_modules/<name>`, and one entry per bin in `bin/`, either a relative symlink
+ * (npm and bun on POSIX) or a launcher script that names the package path (Windows shims and
+ * omo-ai's own bun shim).
+ */
+export declare function writeGlobalPackageBin(options: GlobalBinFixtureOptions): GlobalBinFixture;
+/**
+ * Lays out the `omo` command the Codex Light installer of a pre-rename release wrote into
+ * `~/.local/bin`: a generated shell wrapper, not a package-manager link, that execs the CLI out of
+ * `<CODEX_HOME>/plugins/cache/sisyphuslabs/omo/<version>/`. The marker comment is what the Light
+ * installer itself matches on when it retires the wrapper.
+ */
+export declare function writeCodexLightRuntimeWrapper(options: {
+    readonly root: string;
+    readonly version: string;
+    readonly marker?: string;
+}): {
+    readonly binDir: string;
+    readonly binPath: string;
+};

package/dist/cli/install-native/plan.d.ts

@@ -0,0 +1,21 @@
+/** The omo-ai spec on this plugin's channel: `omo-ai@beta` for a prerelease build, bare `omo-ai` for a stable one. */
+export declare function nativePackageSpec(pluginVersion?: string): string;
+export declare const NATIVE_PACKAGE_SPEC: string;
+export declare const NATIVE_SETUP_COMMAND = "omo setup";
+export declare const NATIVE_RECOMMENDED_RUNTIME_NOTE = "bun is the recommended runtime for OmO Native; npm works, but bun is what OmO Native is tested on.";
+export type NativePackageManager = "bun" | "npm";
+export interface NativeInstallPlan {
+    readonly packageManager: NativePackageManager;
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function resolveNativeInstallPlan(bunAvailable: boolean): NativeInstallPlan;
+export declare function formatNativeInstallCommand(plan: NativeInstallPlan): string;
+/**
+ * The command every user-facing surface advertises. It is the raw package install plus the parts a
+ * raw install cannot do: clearing a stale global `omo` left by a pre-rename release, and checking
+ * that the `omo` PATH resolves afterwards is the one omo-ai owns. The tag follows the channel of the
+ * running plugin: a prerelease build advertises `@beta` (while `latest` is 4.19.4, which rejects
+ * `--platform=native`), a stable build advertises the bare name, which resolves to `latest`.
+ */
+export declare function formatNativeInstallEntryCommand(plan: NativeInstallPlan, pluginVersion?: string): string;

package/dist/cli/install-native/repair-legacy-omo-bin.d.ts

@@ -0,0 +1,26 @@
+import type { OmoBinEntry } from "./legacy-omo-bin";
+export interface LegacyOmoBinRemoval {
+    readonly binPath: string;
+    readonly packageName: string;
+    readonly packageVersion: string | null;
+}
+export interface LegacyOmoBinRepairFailure {
+    readonly binPath: string;
+    readonly reason: string;
+}
+export interface LegacyOmoBinRepair {
+    readonly removed: readonly LegacyOmoBinRemoval[];
+    readonly failures: readonly LegacyOmoBinRepairFailure[];
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+}
+export declare function describePackage(entry: OmoBinEntry): string;
+export declare function removeFileCommand(binPath: string, isWindows: boolean): string;
+/**
+ * Removes only the `omo` command that a pre-rename release left behind. The package that owns it, and
+ * every other command it installs, stay in place: the rename orphaned this one alias, and uninstalling
+ * somebody's whole global package to install ours is not a decision an installer gets to make.
+ */
+export declare function repairLegacyOmoBins(entries: readonly OmoBinEntry[], options: {
+    readonly isWindows: boolean;
+}): LegacyOmoBinRepair;

package/dist/cli/install-native/run-native-install.d.ts

@@ -0,0 +1,33 @@
+import type { OmoBinEnvironment } from "./legacy-omo-bin";
+import type { OmoVersionProbe } from "./verify-omo-command";
+import type { NativeInstallPlan } from "./plan";
+export interface NativeInstallSpawnResult {
+    readonly exitCode: number;
+    readonly stderr?: string;
+}
+export type NativeInstallSpawn = (command: string, args: readonly string[]) => Promise<NativeInstallSpawnResult>;
+export interface NativeInstallDependencies {
+    readonly isBunAvailable: () => boolean | Promise<boolean>;
+    readonly spawn: NativeInstallSpawn;
+    readonly environment: OmoBinEnvironment;
+    readonly probeVersion: OmoVersionProbe;
+}
+export interface NativeInstallFailure {
+    readonly reason: string;
+    readonly manualCommand: string;
+    readonly hints?: readonly string[];
+}
+export interface NativeInstallOutcome {
+    readonly ok: boolean;
+    /** The `omo` that PATH resolves after the install is the one omo-ai owns. */
+    readonly verified: boolean;
+    /** The verified omo-ai binary; set only when `verified`, so onboarding never runs a bare `omo` lookup. */
+    readonly omoBinPath?: string;
+    readonly plan: NativeInstallPlan;
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+    readonly failure?: NativeInstallFailure;
+}
+export declare function runNativeInstall(dependencies?: NativeInstallDependencies): Promise<NativeInstallOutcome>;
+export declare function nativeInstallSuccessLine(verified: boolean): string;
+export declare function nativeInstallFailureLines(failure: NativeInstallFailure): readonly string[];

package/dist/cli/install-native/verify-omo-command.d.ts

@@ -0,0 +1,22 @@
+import type { OmoBinEnvironment } from "./legacy-omo-bin";
+export interface OmoVersionProbeResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+}
+export type OmoVersionProbe = (command: string, args: readonly string[]) => Promise<OmoVersionProbeResult>;
+export type OmoCommandVerification = {
+    readonly ok: true;
+    /** The omo-ai `omo` that was verified. */
+    readonly binPath: string;
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+} | {
+    readonly ok: false;
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+};
+export declare function pathOrderFix(directory: string, isWindows: boolean): string;
+export declare function verifyOmoCommand(options: {
+    readonly environment: OmoBinEnvironment;
+    readonly probeVersion: OmoVersionProbe;
+}): Promise<OmoCommandVerification>;

package/dist/cli/install-native-dev/index.d.ts

@@ -0,0 +1,4 @@
+import { runSenpiInstaller } from "@oh-my-opencode/omo-senpi/install";
+export type NativeDevInstallOptions = NonNullable<Parameters<typeof runSenpiInstaller>[0]>;
+export type NativeDevInstallResult = Awaited<ReturnType<typeof runSenpiInstaller>>;
+export declare function runNativeDevInstaller(options?: NativeDevInstallOptions): Promise<NativeDevInstallResult>;

package/dist/cli/native-dev-platform-flag.d.ts

@@ -0,0 +1,5 @@
+import type { InstallPlatform } from "./types";
+export declare const NATIVE_DEV_PLATFORM_ENV_FLAG = "OMO_ENABLE_NATIVE_DEV_PLATFORM";
+export declare const LEGACY_NATIVE_DEV_PLATFORM_ENV_FLAG = "OMO_ENABLE_SENPI_PLATFORM";
+export declare function isNativeDevPlatformEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function availableInstallPlatforms(env?: NodeJS.ProcessEnv): InstallPlatform[];

package/dist/cli/native-edition-hint.d.ts

@@ -0,0 +1,10 @@
+import type { InstallConfig } from "./types";
+export declare const NATIVE_EDITION_INSTALL_COMMAND: string;
+export declare const NATIVE_EDITION_GUIDE_URL = "https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/migrating-from-opencode.md";
+export declare const NATIVE_EDITION_HINT_TITLE = "OmO Native (beta)";
+export type NativeEditionHintPaint = {
+    readonly command: (text: string) => string;
+    readonly link: (text: string) => string;
+};
+export declare function shouldShowNativeEditionHint(config: Pick<InstallConfig, "hasNative" | "hasNativeDev">): boolean;
+export declare function nativeEditionHintLines(paint?: NativeEditionHintPaint): readonly string[];

package/dist/cli/runtime-commands.d.ts

@@ -1,2 +1,2 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 export declare function configureRuntimeCommands(program: Command): void;

package/dist/cli/types.d.ts

@@ -1,6 +1,6 @@
 export type ClaudeSubscription = "no" | "yes" | "max20";
 export type BooleanArg = "no" | "yes";
-export type InstallPlatform = "opencode" | "codex" | "both" | "senpi";
+export type InstallPlatform = "opencode" | "codex" | "both" | "native" | "native-dev";
 export interface InstallArgs {
     tui: boolean;
     platform?: InstallPlatform;
@@ -28,7 +28,8 @@ export interface InstallConfig {
     hasGemini: boolean;
     hasCopilot: boolean;
     hasCodex: boolean;
-    hasSenpi: boolean;
+    hasNative: boolean;
+    hasNativeDev: boolean;
     hasOpencodeZen: boolean;
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;

package/dist/cli/worktree-sweep/classify.d.ts

@@ -0,0 +1,16 @@
+import type { ClassificationInput, WorktreeClassification, WorktreeRecord } from "./types";
+/**
+ * Externally-owned worktree roots. These are managed by other applications, so
+ * sweeping them would delete state we do not own.
+ */
+export declare const DEFAULT_EXCLUDE_PREFIXES: readonly string[];
+export declare function expandHome(value: string, home: string): string;
+export declare function isExcludedPath(worktreePath: string, prefixes: readonly string[], home: string): boolean;
+/** Branch name when attached, otherwise the detached HEAD sha. */
+export declare function worktreeRef(record: WorktreeRecord): string;
+/**
+ * Single source of truth for sweep decisions. Mirrors the validated `git-wt-cl`
+ * prototype: protection wins over eligibility, and eligibility requires both a
+ * merged (or aged-out) ref and a clean tree.
+ */
+export declare function classifyWorktree(input: ClassificationInput): WorktreeClassification;

package/dist/cli/worktree-sweep/format.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeClassification, WorktreeSweepResult } from "./types";
+/**
+ * One machine-parseable line per worktree:
+ *   `SWEEP <path> <ref>` / `KEEP(<reason>) <path> <ref>` / `PRUNE <path> <ref>`
+ */
+export declare function formatClassification(classification: WorktreeClassification): string;
+export declare function formatSummary(result: WorktreeSweepResult): string;
+export declare function formatResult(result: WorktreeSweepResult): string[];

package/dist/cli/worktree-sweep/git.d.ts

@@ -0,0 +1,19 @@
+export interface GitResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare function runGit(cwd: string, args: readonly string[]): Promise<GitResult>;
+export declare function listWorktreesPorcelain(repo: string): Promise<string>;
+/**
+ * Default branch detection: `origin/HEAD` symbolic ref first, then a local
+ * `main`, then `master`. Mirrors the prototype's fallback chain.
+ */
+export declare function detectDefaultBranch(repo: string): Promise<string | undefined>;
+/** `git merge-base --is-ancestor <ref> <default>` — the merged oracle. */
+export declare function isMerged(repo: string, ref: string, defaultBranch: string): Promise<boolean>;
+export declare function isDirty(worktreePath: string): Promise<boolean>;
+/** Never uses `--force`: git itself refuses dirty and locked worktrees. */
+export declare function removeWorktree(repo: string, worktreePath: string): Promise<GitResult>;
+export declare function pruneWorktrees(repo: string): Promise<GitResult>;
+export declare function resolveRepoRoot(cwd: string): Promise<string | undefined>;

package/dist/cli/worktree-sweep/index.d.ts

@@ -0,0 +1,7 @@
+export { classifyWorktree, DEFAULT_EXCLUDE_PREFIXES, isExcludedPath } from "./classify";
+export { formatClassification, formatResult, formatSummary } from "./format";
+export { parseOlderThanDays } from "./options";
+export { parseWorktreeList, linkedWorktrees } from "./parse-worktree-list";
+export { sweepWorktrees } from "./sweep";
+export { worktreeSweep } from "./worktree-sweep";
+export type { ClassificationInput, WorktreeClassification, WorktreeDecision, WorktreeKeepReason, WorktreeRecord, WorktreeSweepOptions, WorktreeSweepRepoReport, WorktreeSweepResult, } from "./types";

package/dist/cli/worktree-sweep/options.d.ts

@@ -0,0 +1,2 @@
+/** Parses the `--older-than <days>` value: a non-negative integer, else throws. */
+export declare function parseOlderThanDays(value: string): number;

package/dist/cli/worktree-sweep/parse-worktree-list.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeRecord } from "./types";
+/**
+ * Parses `git worktree list --porcelain` output. Records are separated by blank
+ * lines; the first record is always the main worktree.
+ */
+export declare function parseWorktreeList(porcelain: string): WorktreeRecord[];
+/** Drops the main worktree (first record), which is never a sweep candidate. */
+export declare function linkedWorktrees(records: readonly WorktreeRecord[]): WorktreeRecord[];

package/dist/cli/worktree-sweep/sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions, WorktreeSweepResult } from "./types";
+export declare function sweepWorktrees(options?: WorktreeSweepOptions): Promise<WorktreeSweepResult>;

package/dist/cli/worktree-sweep/types.d.ts

@@ -0,0 +1,65 @@
+export interface WorktreeRecord {
+    /** Absolute worktree path as reported by `git worktree list --porcelain`. */
+    readonly path: string;
+    /** Commit SHA of the worktree HEAD, when reported. */
+    readonly head?: string;
+    /** Short branch name (`refs/heads/` stripped), when the worktree is attached. */
+    readonly branch?: string;
+    readonly detached: boolean;
+    readonly locked: boolean;
+    /** Lock reason string recorded by `git worktree lock --reason`, when present. */
+    readonly lockReason?: string;
+    readonly prunable: boolean;
+}
+export type WorktreeDecision = "SWEEP" | "KEEP" | "PRUNE";
+export type WorktreeKeepReason = "locked" | "external" | "unmerged" | "dirty";
+export interface WorktreeClassification {
+    readonly path: string;
+    /** Branch name when attached, otherwise the HEAD sha; empty when neither is known. */
+    readonly ref: string;
+    readonly decision: WorktreeDecision;
+    readonly reason?: WorktreeKeepReason;
+}
+export interface ClassificationInput {
+    readonly record: WorktreeRecord;
+    /** False when the worktree path no longer exists on disk. */
+    readonly pathExists: boolean;
+    readonly merged: boolean;
+    /** True when `--older-than` is satisfied; always false when `--older-than=0`. */
+    readonly agedOut: boolean;
+    readonly dirty: boolean;
+    /** True when the path lives under one of the configured protected prefixes. */
+    readonly external: boolean;
+}
+export interface WorktreeSweepRepoReport {
+    readonly repo: string;
+    readonly defaultBranch: string;
+    readonly classifications: readonly WorktreeClassification[];
+    /** Paths actually removed; always empty in dry-run mode. */
+    readonly removed: readonly string[];
+    /** Paths that `git worktree remove` refused, with the git error text. */
+    readonly failed: readonly {
+        readonly path: string;
+        readonly error: string;
+    }[];
+}
+export interface WorktreeSweepResult {
+    readonly apply: boolean;
+    readonly olderThanDays: number;
+    readonly repos: readonly WorktreeSweepRepoReport[];
+    readonly sweepCount: number;
+    readonly keepCount: number;
+    readonly pruneCount: number;
+}
+export interface WorktreeSweepOptions {
+    /** Dry-run is the default; only an explicit `true` removes anything. */
+    readonly apply?: boolean;
+    /** 0 means merged-only: unmerged worktrees are never swept. */
+    readonly olderThanDays?: number;
+    /** Repositories to sweep; defaults to the current working directory's repo. */
+    readonly repos?: readonly string[];
+    readonly json?: boolean;
+    /** Overrides the built-in externally-owned path prefixes. */
+    readonly excludePrefixes?: readonly string[];
+    readonly cwd?: string;
+}

package/dist/cli/worktree-sweep/worktree-sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions } from "./types";
+export declare function worktreeSweep(options?: WorktreeSweepOptions): Promise<number>;