@skj1724/oh-my-opencode 3.19.3 → 3.19.5

package/bin/oh-my-opencode.js

@@ -4,9 +4,13 @@
 
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { getPlatformPackage, getBinaryPath } from "./platform.js";
 
 const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const distCliPath = join(__dirname, "..", "dist", "cli", "index.js");
 
 /**
  * Detect libc family on Linux
@@ -29,52 +33,55 @@ function getLibcFamily() {
 function main() {
   const { platform, arch } = process;
   const libcFamily = getLibcFamily();
+  const args = process.argv.slice(2);
   
-  // Get platform package name
-  let pkg;
-  try {
-    pkg = getPlatformPackage({ platform, arch, libcFamily });
-  } catch (error) {
-    console.error(`\noh-my-opencode: ${error.message}\n`);
-    process.exit(1);
-  }
-  
-  // Resolve binary path
-  const binRelPath = getBinaryPath(pkg, platform);
-  
-  let binPath;
+  let binPath = null;
   try {
+    const pkg = getPlatformPackage({ platform, arch, libcFamily });
+    const binRelPath = getBinaryPath(pkg, platform);
     binPath = require.resolve(binRelPath);
   } catch {
-    console.error(`\noh-my-opencode: Platform binary not installed.`);
-    console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
-    console.error(`Expected package: ${pkg}`);
-    console.error(`\nTo fix, run:`);
-    console.error(`  npm install ${pkg}\n`);
-    process.exit(1);
   }
   
-  // Spawn the binary
-  const result = spawnSync(binPath, process.argv.slice(2), {
+  if (binPath) {
+    const result = spawnSync(binPath, args, {
+      stdio: "inherit",
+    });
+    
+    if (!result.error && !result.signal) {
+      process.exit(result.status ?? 0);
+    }
+    
+    if (result.error) {
+      console.warn(`\noh-my-opencode: Platform binary failed: ${result.error.message}`);
+    } else if (result.signal) {
+      console.warn(`\noh-my-opencode: Platform binary crashed (signal: ${result.signal})`);
+    }
+    console.warn("  Falling back to Bun...\n");
+  }
+  
+  const fallbackResult = spawnSync("bun", ["run", distCliPath, ...args], {
     stdio: "inherit",
   });
   
-  // Handle spawn errors
-  if (result.error) {
-    console.error(`\noh-my-opencode: Failed to execute binary.`);
-    console.error(`Error: ${result.error.message}\n`);
+  if (fallbackResult.error) {
+    console.error(`\noh-my-opencode: Failed to execute CLI via Bun.`);
+    if (fallbackResult.error.code === "ENOENT") {
+      console.error(`  Bun is not installed. Install it from https://bun.sh\n`);
+    } else {
+      console.error(`  Error: ${fallbackResult.error.message}\n`);
+    }
     process.exit(2);
   }
   
-  // Handle signals
-  if (result.signal) {
-    const signalNum = result.signal === "SIGTERM" ? 15 : 
-                      result.signal === "SIGKILL" ? 9 :
-                      result.signal === "SIGINT" ? 2 : 1;
+  if (fallbackResult.signal) {
+    const signalNum = fallbackResult.signal === "SIGTERM" ? 15 :
+                      fallbackResult.signal === "SIGKILL" ? 9 :
+                      fallbackResult.signal === "SIGINT" ? 2 : 1;
     process.exit(128 + signalNum);
   }
-
-  process.exit(result.status ?? 1);
+  
+  process.exit(fallbackResult.status ?? 1);
 }
 
 main();

package/dist/cli/index.js

@@ -6117,6 +6117,59 @@ var init_model_resolver = __esm(() => {
   init_model_availability();
 });
 
+// src/shared/perf-timer.ts
+class PerfTimer {
+  marks = new Map;
+  spans = [];
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  measure(name, startMark, endMark) {
+    const start = this.marks.get(startMark);
+    if (start === undefined)
+      return 0;
+    const end = endMark ? this.marks.get(endMark) ?? performance.now() : performance.now();
+    const duration = end - start;
+    this.spans.push({ name, durationMs: duration, start, end });
+    return duration;
+  }
+  getReport() {
+    return [...this.spans];
+  }
+  reset() {
+    this.marks.clear();
+    this.spans = [];
+  }
+  static formatDuration(start, end, options) {
+    const ms = (end ?? new Date).getTime() - start.getTime();
+    const absMs = Math.abs(ms);
+    const totalSeconds = absMs / 1000;
+    const seconds = Math.floor(totalSeconds);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const precision = options?.precision ?? "full";
+    if (hours > 0) {
+      if (precision === "compact") {
+        return `${hours}h ${minutes % 60}m`;
+      }
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    if (seconds === 0 && absMs > 0) {
+      return `${(absMs / 1000).toFixed(1)}s`;
+    }
+    return `${seconds}s`;
+  }
+}
+
+// src/shared/perf-tracer.ts
+var init_perf_tracer = () => {};
+
+// src/shared/fileio-monitor.ts
+var init_fileio_monitor = () => {};
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -6144,6 +6197,8 @@ var init_shared = __esm(() => {
   init_model_requirements();
   init_model_resolver();
   init_model_availability();
+  init_perf_tracer();
+  init_fileio_monitor();
 });
 
 // src/cli/model-fallback.ts
@@ -8375,7 +8430,7 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "@skj1724/oh-my-opencode",
-  version: "3.19.3",
+  version: "3.19.5",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -24913,6 +24968,7 @@ var HookNameSchema = exports_external.enum([
   "edit-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
+  "perf-profiler",
   "start-work",
   "atlas"
 ]);
@@ -25026,11 +25082,21 @@ var DynamicContextPruningConfigSchema = exports_external.object({
     }).optional()
   }).optional()
 });
+var ProfilingConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  output_dir: exports_external.string().optional(),
+  slow_threshold_ms: exports_external.number().default(100),
+  memory_snapshot_interval: exports_external.number().default(5),
+  trace_api: exports_external.boolean().default(true),
+  trace_fileio: exports_external.boolean().default(true),
+  trace_polling: exports_external.boolean().default(true)
+});
 var ExperimentalConfigSchema = exports_external.object({
   aggressive_truncation: exports_external.boolean().optional(),
   auto_resume: exports_external.boolean().optional(),
   truncate_all_tool_outputs: exports_external.boolean().optional(),
-  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional()
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
+  profiling: ProfilingConfigSchema.optional()
 });
 var SkillSourceSchema = exports_external.union([
   exports_external.string(),

package/dist/config/schema.d.ts

@@ -71,6 +71,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     "edit-error-recovery": "edit-error-recovery";
     "delegate-task-retry": "delegate-task-retry";
     "prometheus-md-only": "prometheus-md-only";
+    "perf-profiler": "perf-profiler";
     "start-work": "start-work";
 }>;
 export declare const BuiltinCommandNameSchema: z.ZodEnum<{
@@ -890,6 +891,15 @@ export declare const DynamicContextPruningConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export declare const ProfilingConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    output_dir: z.ZodOptional<z.ZodString>;
+    slow_threshold_ms: z.ZodDefault<z.ZodNumber>;
+    memory_snapshot_interval: z.ZodDefault<z.ZodNumber>;
+    trace_api: z.ZodDefault<z.ZodBoolean>;
+    trace_fileio: z.ZodDefault<z.ZodBoolean>;
+    trace_polling: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 export declare const ExperimentalConfigSchema: z.ZodObject<{
     aggressive_truncation: z.ZodOptional<z.ZodBoolean>;
     auto_resume: z.ZodOptional<z.ZodBoolean>;
@@ -920,6 +930,15 @@ export declare const ExperimentalConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    profiling: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        output_dir: z.ZodOptional<z.ZodString>;
+        slow_threshold_ms: z.ZodDefault<z.ZodNumber>;
+        memory_snapshot_interval: z.ZodDefault<z.ZodNumber>;
+        trace_api: z.ZodDefault<z.ZodBoolean>;
+        trace_fileio: z.ZodDefault<z.ZodBoolean>;
+        trace_polling: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const SkillSourceSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     path: z.ZodString;
@@ -1043,6 +1062,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "edit-error-recovery": "edit-error-recovery";
         "delegate-task-retry": "delegate-task-retry";
         "prometheus-md-only": "prometheus-md-only";
+        "perf-profiler": "perf-profiler";
         "start-work": "start-work";
     }>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -1778,6 +1798,15 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        profiling: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            output_dir: z.ZodOptional<z.ZodString>;
+            slow_threshold_ms: z.ZodDefault<z.ZodNumber>;
+            memory_snapshot_interval: z.ZodDefault<z.ZodNumber>;
+            trace_api: z.ZodDefault<z.ZodBoolean>;
+            trace_fileio: z.ZodDefault<z.ZodBoolean>;
+            trace_polling: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
     skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
@@ -1833,6 +1862,7 @@ export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>;
 export type CommentCheckerConfig = z.infer<typeof CommentCheckerConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
 export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>;
+export type ProfilingConfig = z.infer<typeof ProfilingConfigSchema>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
 export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;

package/dist/features/background-agent/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export { BackgroundManager } from "./manager";
 export { ConcurrencyManager } from "./concurrency";
+export { PerformanceAggregator } from "./perf-aggregator";

package/dist/features/background-agent/manager.d.ts

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
+import type { PerfTracer } from "../../shared/perf-tracer";
 import type { BackgroundTaskConfig } from "../../config/schema";
 interface EventProperties {
     sessionID?: string;
@@ -25,9 +26,12 @@ export declare class BackgroundManager {
     private concurrencyManager;
     private shutdownTriggered;
     private config?;
+    private perfAggregator;
+    private perfTracer?;
     private queuesByKey;
     private processingKeys;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig);
+    setPerfTracer(tracer: PerfTracer): void;
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;
     private startTask;
@@ -89,7 +93,6 @@ export declare class BackgroundManager {
      */
     private tryCompleteTask;
     private notifyParentSession;
-    private formatDuration;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
     private checkAndInterruptStaleTasks;

package/dist/features/background-agent/perf-aggregator.d.ts

@@ -0,0 +1,26 @@
+import type { BackgroundTask } from "./types";
+export interface AgentStat {
+    count: number;
+    avgMs: number;
+    p50Ms: number;
+    p95Ms: number;
+    totalMs: number;
+}
+export interface AggregatedReport {
+    totalTasks: number;
+    tasksByAgent: Map<string, AgentStat>;
+    totalToolCalls: number;
+    queueWaitStats: {
+        avgMs: number;
+        p50Ms: number;
+        p95Ms: number;
+        maxMs: number;
+    };
+}
+export declare class PerformanceAggregator {
+    private tasks;
+    recordTaskCompletion(task: BackgroundTask): void;
+    getReport(): AggregatedReport;
+    reset(): void;
+    get taskCount(): number;
+}

package/dist/features/background-agent/types.d.ts

@@ -1,10 +1,25 @@
 export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled";
+export interface PhaseTiming {
+    /** queuedAt -> startedAt in ms */
+    queueWaitMs: number;
+    /** startedAt -> completedAt in ms */
+    totalRunMs: number;
+    /** startedAt -> first assistant message in ms */
+    firstResponseMs?: number;
+    /** startedAt -> last message in ms */
+    lastResponseMs?: number;
+    /** Total tool call count */
+    toolCallCount: number;
+    /** toolCallCount / totalRunMs * 60000 (calls per minute) */
+    toolCallRate?: number;
+}
 export interface TaskProgress {
     toolCalls: number;
     lastTool?: string;
     lastUpdate: Date;
     lastMessage?: string;
     lastMessageAt?: Date;
+    phaseTiming?: PhaseTiming;
 }
 export interface BackgroundTask {
     id: string;

package/dist/features/hook-message-injector/injector.d.ts

@@ -8,11 +8,5 @@ export interface StoredMessage {
     tools?: Record<string, ToolPermission>;
 }
 export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
-/**
- * Finds the FIRST (oldest) message in the session with agent field.
- * This is used to get the original agent that started the session,
- * avoiding issues where newer messages may have a different agent
- * due to OpenCode's internal agent switching.
- */
 export declare function findFirstMessageWithAgent(messageDir: string): string | null;
 export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;

package/dist/hooks/index.d.ts

@@ -28,3 +28,4 @@ export { createStartWorkHook } from "./start-work";
 export { createAtlasHook } from "./atlas";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
+export { createPerfProfilerHook } from "./perf-profiler";

package/dist/hooks/perf-profiler/index.d.ts

@@ -0,0 +1,2 @@
+import type { PerfProfilerOptions, PerfProfilerHook } from "./types";
+export declare function createPerfProfilerHook(options: PerfProfilerOptions): PerfProfilerHook;

package/dist/hooks/perf-profiler/index.test.d.ts

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

package/dist/hooks/perf-profiler/types.d.ts

@@ -0,0 +1,42 @@
+import type { ProfilingConfig } from "../../config/schema";
+import type { PerfTracer } from "../../shared/perf-tracer";
+export interface PerfProfilerOptions {
+    config: ProfilingConfig;
+    tracer: PerfTracer;
+    /** 注册 Map/Set size 采集回调，key 为探针名称，fn 返回当前 size */
+    memoryProbes?: Record<string, () => number>;
+}
+export interface PerfProfilerHook {
+    "event": (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+    }, output: {
+        message: Record<string, unknown>;
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+}

package/dist/hooks/think-mode/index.d.ts

@@ -1,10 +1,34 @@
-import type { ThinkModeInput } from "./types";
 export * from "./detector";
 export * from "./switcher";
 export * from "./types";
 export declare function clearThinkModeState(sessionID: string): void;
 export declare function createThinkModeHook(): {
-    "chat.params": (output: ThinkModeInput, sessionID: string) => Promise<void>;
+    "chat.params": (input: {
+        sessionID: string;
+        agent: string;
+        model: {
+            id: string;
+            providerID: string;
+        };
+        provider: {
+            source: string;
+            info: unknown;
+            options: Record<string, unknown>;
+        };
+        message: {
+            role: string;
+            parts?: Array<{
+                type: string;
+                text?: string;
+            }>;
+        };
+    }, output: {
+        temperature: number;
+        topP: number;
+        topK: number;
+        maxOutputTokens: number | undefined;
+        options: Record<string, unknown>;
+    }) => Promise<void>;
     event: ({ event }: {
         event: {
             type: string;

package/dist/hooks/think-mode/types.d.ts

@@ -1,3 +1,5 @@
+import type { Model, UserMessage } from "@opencode-ai/sdk";
+import type { ProviderContext } from "@opencode-ai/plugin";
 export interface ThinkModeState {
     requested: boolean;
     modelSwitched: boolean;
@@ -5,17 +7,17 @@ export interface ThinkModeState {
     providerID?: string;
     modelID?: string;
 }
-export interface ModelRef {
-    providerID: string;
-    modelID: string;
-}
-export interface MessageWithModel {
-    model?: ModelRef;
-}
 export interface ThinkModeInput {
-    parts: Array<{
-        type: string;
-        text?: string;
-    }>;
-    message: MessageWithModel;
+    sessionID: string;
+    agent: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+export interface ThinkModeOutput {
+    temperature: number;
+    topP: number;
+    topK: number;
+    maxOutputTokens: number | undefined;
+    options: Record<string, unknown>;
 }