@reinamaccredy/maestro 1.0.1 → 1.2.0

package/dist/shared/config-path.d.ts

@@ -8,10 +8,10 @@
  */
 export declare function getUserConfigDir(): string;
 /**
- * Returns the full path to the user-level oh-my-opencode config file.
+ * Returns the full path to the user-level maestro config file.
  */
 export declare function getUserConfigPath(): string;
 /**
- * Returns the full path to the project-level oh-my-opencode config file.
+ * Returns the full path to the project-level maestro config file.
  */
 export declare function getProjectConfigPath(directory: string): string;

package/dist/shared/external-plugin-detector.d.ts

@@ -1,5 +1,5 @@
 /**
- * Detects external plugins that may conflict with oh-my-opencode features.
+ * Detects external plugins that may conflict with maestro features.
  * Used to prevent crashes from concurrent notification plugins.
  */
 export interface ExternalNotifierResult {

package/dist/shared/index.d.ts

@@ -26,3 +26,4 @@ export * from "./session-cursor";
 export * from "./shell-env";
 export * from "./system-directive";
 export * from "./agent-tool-restrictions";
+export * from "./platform-detection";

package/dist/shared/platform-detection.d.ts

@@ -0,0 +1,42 @@
+export type Platform = "opencode" | "claude-code" | "amp" | "codex" | "unknown";
+/**
+ * Detect which AI coding platform is running this plugin.
+ *
+ * Detection priority:
+ * 1. Plugin context (for OpenCode - ctx.client exists)
+ * 2. Environment variables (most reliable for other platforms)
+ * 3. Directory presence (fallback)
+ */
+export declare function detectPlatform(ctx?: {
+    client?: unknown;
+    directory?: string;
+}): Platform;
+/**
+ * Check if running on Amp Code with native oracle tool.
+ *
+ * Amp Code provides oracle/librarian as NATIVE TOOLS, not agents.
+ * When true, we should NOT register our Virtuoso/Archivist agents.
+ *
+ * Detection: Check if platform is Amp or if tool registry contains
+ * a tool named "oracle" that is NOT one of our registered agents.
+ */
+export declare function hasNativeOracle(ctx?: {
+    tools?: Map<string, unknown>;
+}): boolean;
+/**
+ * Check if running on Amp Code with native librarian tool.
+ * Same logic as hasNativeOracle.
+ */
+export declare function hasNativeLibrarian(ctx?: {
+    tools?: Map<string, unknown>;
+}): boolean;
+/**
+ * Get platform-specific skill directory.
+ * Different platforms look for skills in different locations.
+ */
+export declare function getSkillDirectory(platform: Platform): string;
+/**
+ * Check if we should skip registering our agents because
+ * native equivalents exist on the current platform.
+ */
+export declare function shouldSkipAgent(agentName: string): boolean;

package/dist/shared/system-directive.d.ts

@@ -1,5 +1,5 @@
 /**
- * Unified system directive prefix for oh-my-opencode internal messages.
+ * Unified system directive prefix for maestro internal messages.
  * All system-generated messages should use this prefix for consistent filtering.
  *
  * Format: [SYSTEM DIRECTIVE: OH-MY-OPENCODE - {TYPE}]
@@ -12,7 +12,7 @@ export declare const SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: OH-MY-OPENCOD
  */
 export declare function createSystemDirective(type: string): string;
 /**
- * Checks if a message starts with the oh-my-opencode system directive prefix.
+ * Checks if a message starts with the maestro system directive prefix.
  * Used by keyword-detector and other hooks to skip system-generated messages.
  * @param text - The message text to check
  * @returns true if the message is a system directive

package/dist/tools/background-task/tools.d.ts

@@ -1,5 +1,5 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
-import type { BackgroundManager } from "../../features/background-agent";
+import type { BackgroundManager } from "../../features/background/agent";
 type OpencodeClient = PluginInput["client"];
 export declare function createBackgroundTask(manager: BackgroundManager): ToolDefinition;
 export declare function createBackgroundOutput(manager: BackgroundManager, client: OpencodeClient): ToolDefinition;

package/dist/tools/call-omo-agent/tools.d.ts

@@ -1,3 +1,3 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
-import type { BackgroundManager } from "../../features/background-agent";
+import type { BackgroundManager } from "../../features/background/agent";
 export declare function createCallOmoAgent(ctx: PluginInput, backgroundManager: BackgroundManager): ToolDefinition;

package/dist/tools/delegate-task/tools.d.ts

@@ -1,5 +1,5 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
-import type { BackgroundManager } from "../../features/background-agent";
+import type { BackgroundManager } from "../../features/background/agent";
 import type { CategoriesConfig, GitMasterConfig } from "../../config/schema";
 type OpencodeClient = PluginInput["client"];
 export interface DelegateTaskToolOptions {

package/dist/tools/index.d.ts

@@ -7,7 +7,7 @@ export { createSkillTool } from "./skill";
 export { getTmuxPath } from "./interactive-bash/utils";
 export { createSkillMcpTool } from "./skill-mcp";
 import type { PluginInput, ToolDefinition } from "@opencode-ai/plugin";
-import type { BackgroundManager } from "../features/background-agent";
+import type { BackgroundManager } from "../features/background/agent";
 type OpencodeClient = PluginInput["client"];
 export { createCallOmoAgent } from "./call-omo-agent";
 export { createLookAt } from "./look-at";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reinamaccredy/maestro",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Maestro - Context-driven development for AI coding agents with music-themed orchestration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/postinstall.mjs

@@ -1,10 +1,16 @@
 // postinstall.mjs
-// Runs after npm install to verify platform binary is available
+// Runs after npm install to:
+// 1. Verify platform binary is available
+// 2. Create skill symlinks for multi-platform compatibility
 
 import { createRequire } from "node:module";
+import { existsSync, symlinkSync, mkdirSync, realpathSync, lstatSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { getPlatformPackage, getBinaryPath } from "./bin/platform.js";
 
 const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 /**
  * Detect libc family on Linux
@@ -22,7 +28,89 @@ function getLibcFamily() {
   }
 }
 
-function main() {
+/**
+ * Check if path is a symlink
+ */
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create skill symlinks for multi-platform compatibility.
+ * Creates symlinks from platform-specific skill directories to our builtin-skills.
+ */
+function createSkillSymlinks() {
+  // Skills are in the npm package at src/features/builtin-skills/
+  // __dirname is the package root (where postinstall.mjs lives)
+  const skillsSource = join(__dirname, "src", "features", "builtin-skills");
+  
+  // Verify skills source exists (should always exist in published package)
+  if (!existsSync(skillsSource)) {
+    console.log("[SKIP] Skills source not found (development install?)");
+    return;
+  }
+
+  // User's project root (where npm install was run)
+  const projectRoot = process.cwd();
+  
+  // Skip if we're in the package directory itself (development)
+  if (projectRoot === __dirname) {
+    console.log("[SKIP] Development install detected");
+    return;
+  }
+
+  const symlinks = [
+    { target: ".claude/skills", platform: "claude-code" },
+    { target: ".opencode/skill", platform: "opencode" },
+    { target: ".codex/skills", platform: "codex" },
+    { target: ".agents/skills", platform: "amp" },
+  ];
+
+  console.log("Creating skill symlinks...");
+
+  for (const { target, platform } of symlinks) {
+    const targetPath = join(projectRoot, target);
+    const targetDir = dirname(targetPath);
+
+    // Don't overwrite existing directories/files (unless it's our symlink)
+    if (existsSync(targetPath) && !isSymlink(targetPath)) {
+      console.log(`  [SKIP] ${target} already exists (${platform})`);
+      continue;
+    }
+    
+    // If it's an existing symlink, skip (already set up)
+    if (isSymlink(targetPath)) {
+      console.log(`  [OK] ${target} symlink exists (${platform})`);
+      continue;
+    }
+
+    try {
+      // Create parent directory if needed
+      if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
+
+      // On Windows, use junction (doesn't require admin)
+      // On Unix, use absolute path for reliability
+      if (process.platform === "win32") {
+        symlinkSync(skillsSource, targetPath, "junction");
+      } else {
+        const absoluteSource = realpathSync(skillsSource);
+        symlinkSync(absoluteSource, targetPath);
+      }
+      console.log(`  [OK] Created ${target} -> builtin-skills (${platform})`);
+    } catch (error) {
+      // Warn but don't fail installation
+      console.warn(`  [WARN] Failed to create ${target}: ${error.message}`);
+    }
+  }
+}
+
+function checkBinary() {
   const { platform, arch } = process;
   const libcFamily = getLibcFamily();
   
@@ -32,12 +120,17 @@ function main() {
     
     // Try to resolve the binary
     require.resolve(binPath);
-    console.log(`✓ oh-my-opencode binary installed for ${platform}-${arch}`);
+    console.log(`[OK] Maestro binary installed for ${platform}-${arch}`);
   } catch (error) {
-    console.warn(`⚠ oh-my-opencode: ${error.message}`);
+    console.warn(`[WARN] Maestro: ${error.message}`);
     console.warn(`  The CLI may not work on this platform.`);
     // Don't fail installation - let user try anyway
   }
 }
 
+function main() {
+  checkBinary();
+  createSkillSymlinks();
+}
+
 main();