@evo-dev/evodev 0.0.1-alpha

package/dist/plugins/evodev/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "evodev",
+  "description": "EvoDev hook integration for disciplined AI coding workflows.",
+  "version": "0.1.0",
+  "author": {
+    "name": "EvoDev"
+  },
+  "license": "MIT"
+}

package/dist/plugins/evodev/.codex-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "evodev",
+  "version": "0.1.0",
+  "description": "EvoDev hook integration for disciplined AI coding workflows.",
+  "author": {
+    "name": "EvoDev"
+  },
+  "license": "MIT",
+  "hooks": "./hooks/codex-hooks.json",
+  "interface": {
+    "displayName": "EvoDev",
+    "shortDescription": "Disciplined AI coding workflow integration.",
+    "longDescription": "EvoDev integrates with Codex plugin installation while keeping Codex skill and agent sync reserved until capability verification is complete.",
+    "developerName": "EvoDev",
+    "category": "Productivity",
+    "capabilities": ["Plugin Install"],
+    "defaultPrompt": ["Check EvoDev doctor status."]
+  }
+}

package/dist/plugins/evodev/hooks/codex-hooks.json

@@ -0,0 +1,121 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NODE_PATH=\"$(dirname \"$(bun pm bin -g)\")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}\" bun run \"${PLUGIN_ROOT}/hooks/runtime.ts\" hook runtime --target codex",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/plugins/evodev/hooks/codex.ts

@@ -0,0 +1,257 @@
+import type {
+  CodeAgentCapabilities,
+  CodeAgentPlugin,
+  DoctorCheck,
+  DoctorContext,
+  PluginDetectionResult,
+  PluginInstallInput,
+  PluginInstallResult,
+  SyncAgentsInput,
+  SyncResult,
+  SyncSkillsInput,
+} from "@evo-dev/core/plugins";
+import { runNodeCommand } from "./command-runner.ts";
+
+const CODEX_RESERVED_MESSAGE =
+  "Codex asset sync is reserved until Codex capabilities and formats are verified.";
+
+export interface CodexCommandResult {
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+export interface CodexCommandRunner {
+  run(command: string, args: string[]): Promise<CodexCommandResult>;
+}
+
+export interface CodexPluginOptions {
+  commandRunner?: CodexCommandRunner;
+  pluginSelector?: string;
+  pluginMarketplaceSource?: string;
+}
+
+export function createCodexPlugin(options: CodexPluginOptions = {}): CodeAgentPlugin {
+  return {
+    id: "codex",
+    name: "Codex",
+    async detect(): Promise<PluginDetectionResult> {
+      return detectCodex({ commandRunner: options.commandRunner });
+    },
+    async getCapabilities(): Promise<CodeAgentCapabilities> {
+      return {
+        skills: { supported: false, format: "codex-skill" },
+        agents: { supported: false, format: "codex-agent" },
+        hooks: { supported: false, events: [] },
+      };
+    },
+    async doctor(context: DoctorContext): Promise<DoctorCheck[]> {
+      const enabled = context.settings.plugins.codex.enabled;
+      const detection = await detectCodex({ commandRunner: options.commandRunner });
+
+      return [
+        detectionToDoctorCheck(detection),
+        {
+          id: "codex.assets.reserved",
+          status: enabled ? "warn" : "skip",
+          message: enabled
+            ? `${CODEX_RESERVED_MESSAGE} Code Agent plugin install is supported, but Codex skill/agent asset sync remains disabled.`
+            : `${CODEX_RESERVED_MESSAGE} Codex is disabled in settings.`,
+        },
+      ];
+    },
+    async syncSkills(input: SyncSkillsInput): Promise<SyncResult> {
+      const result = createSkippedSyncResult(input.targetPlugin);
+      for (const skill of input.skills) {
+        result.skipped.push(skill.registryKey);
+      }
+      addCodexSyncDiagnostic(result, input.dryRun, "skill");
+      return result;
+    },
+    async syncAgents(input: SyncAgentsInput): Promise<SyncResult> {
+      const result = createSkippedSyncResult(input.targetPlugin);
+      for (const agent of input.agents) {
+        result.skipped.push(agent.registryKey);
+      }
+      addCodexSyncDiagnostic(result, input.dryRun, "agent");
+      return result;
+    },
+    async installPlugin(input: PluginInstallInput): Promise<PluginInstallResult> {
+      return installCodexPlugin(input, options);
+    },
+  };
+}
+
+export const codexPlugin = createCodexPlugin();
+
+async function detectCodex(
+  options: Pick<CodexPluginOptions, "commandRunner">,
+): Promise<PluginDetectionResult> {
+  const command = "codex";
+  const runner = options.commandRunner ?? new NodeCodexCommandRunner();
+
+  try {
+    const result = await runner.run(command, ["--version"]);
+    if (result.exitCode === 0) {
+      const version = result.stdout?.trim();
+      return {
+        status: "installed",
+        message: version ? `Codex available: ${version}` : "Codex available: codex",
+      };
+    }
+
+    return {
+      status: isMissingExit(result.exitCode, result.stderr) ? "missing" : "unknown",
+      message: isMissingExit(result.exitCode, result.stderr)
+        ? "Codex command not found: codex"
+        : `Codex detection returned exit code ${result.exitCode}`,
+    };
+  } catch (error) {
+    return {
+      status: isCommandMissingError(error) ? "missing" : "unknown",
+      message: isCommandMissingError(error)
+        ? "Codex command not found: codex"
+        : `Codex detection failed: ${describeError(error)}`,
+    };
+  }
+}
+
+async function installCodexPlugin(
+  input: PluginInstallInput,
+  options: Pick<CodexPluginOptions, "commandRunner" | "pluginSelector" | "pluginMarketplaceSource">,
+): Promise<PluginInstallResult> {
+  const command = "codex";
+  const selector = options.pluginSelector ?? "evodev@evodev";
+  const args = ["plugin", "add", selector];
+  const runner = options.commandRunner ?? new NodeCodexCommandRunner();
+
+  try {
+    if (options.pluginMarketplaceSource !== undefined) {
+      const marketplaceResult = await runner.run(command, [
+        "plugin",
+        "marketplace",
+        "add",
+        options.pluginMarketplaceSource,
+      ]);
+      if (marketplaceResult.exitCode !== 0) {
+        return createPluginInstallResult(
+          input.targetPlugin,
+          "failed",
+          command,
+          args,
+          marketplaceResult.stderr ??
+            marketplaceResult.stdout ??
+            `Codex marketplace add exited with code ${marketplaceResult.exitCode}`,
+        );
+      }
+    }
+
+    const result = await runner.run(command, args);
+    if (result.exitCode === 0) {
+      return createPluginInstallResult(
+        input.targetPlugin,
+        "installed",
+        command,
+        args,
+        result.stdout,
+      );
+    }
+
+    return createPluginInstallResult(
+      input.targetPlugin,
+      "failed",
+      command,
+      args,
+      result.stderr ?? result.stdout ?? `Codex plugin add exited with code ${result.exitCode}`,
+    );
+  } catch (error) {
+    return createPluginInstallResult(
+      input.targetPlugin,
+      "failed",
+      command,
+      args,
+      describeError(error),
+    );
+  }
+}
+
+class NodeCodexCommandRunner implements CodexCommandRunner {
+  async run(command: string, args: string[]): Promise<CodexCommandResult> {
+    return runNodeCommand(command, args);
+  }
+}
+
+function detectionToDoctorCheck(detection: PluginDetectionResult): DoctorCheck {
+  if (detection.status === "installed") {
+    return { id: "codex.available", status: "pass", message: detection.message };
+  }
+
+  if (detection.status === "missing") {
+    return { id: "codex.available", status: "warn", message: detection.message };
+  }
+
+  return { id: "codex.available", status: "warn", message: detection.message };
+}
+
+function createSkippedSyncResult(targetPlugin: string): SyncResult {
+  return {
+    targetPlugin,
+    syncedSkills: [],
+    syncedAgents: [],
+    skipped: [],
+    warnings: [],
+    errors: [],
+  };
+}
+
+function addCodexSyncDiagnostic(
+  result: SyncResult,
+  dryRun: boolean,
+  assetKind: "skill" | "agent",
+): void {
+  const message = `Codex ${assetKind} sync unsupported: capabilities are unverified; no writes planned in I10.`;
+  if (dryRun) result.warnings.push(message);
+  else result.errors.push(message);
+}
+
+function createPluginInstallResult(
+  targetPlugin: string,
+  status: PluginInstallResult["status"],
+  command: string,
+  args: string[],
+  message?: string,
+): PluginInstallResult {
+  const normalizedMessage = message?.trim() || `${command} ${args.join(" ")}`;
+  return {
+    targetPlugin,
+    status,
+    command,
+    args,
+    message: normalizedMessage,
+    warnings: [],
+    errors: status === "failed" ? [normalizedMessage] : [],
+  };
+}
+
+function isMissingExit(exitCode: number, stderr?: string): boolean {
+  if (exitCode === 127) return true;
+  const normalized = stderr?.toLowerCase() ?? "";
+  return normalized.includes("command not found") || normalized.includes("not recognized");
+}
+
+function isCommandMissingError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    ("code" in error
+      ? (error as NodeJS.ErrnoException).code === "ENOENT"
+      : error.message.includes("ENOENT"))
+  );
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}

package/dist/plugins/evodev/hooks/command-runner.ts

@@ -0,0 +1,30 @@
+import { spawn } from "node:child_process";
+
+export interface NodeCommandResult {
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+export async function runNodeCommand(command: string, args: string[]): Promise<NodeCommandResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("close", (code) => {
+      resolve({ exitCode: code ?? 1, stdout, stderr });
+    });
+  });
+}

package/dist/plugins/evodev/hooks/detect.ts

@@ -0,0 +1,101 @@
+import type { PluginDetectionResult } from "@evo-dev/core/plugins";
+import { runNodeCommand } from "./command-runner.ts";
+
+export interface ClaudeCommandResult {
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+export interface ClaudeCommandRunner {
+  run(command: string, args: string[]): Promise<ClaudeCommandResult>;
+}
+
+export interface DetectClaudeOptions {
+  commandRunner?: ClaudeCommandRunner;
+  command?: string;
+}
+
+export async function detectClaudeCode(
+  options: DetectClaudeOptions = {},
+): Promise<PluginDetectionResult> {
+  const command = options.command ?? "claude";
+  const runner = options.commandRunner ?? new NodeClaudeCommandRunner();
+
+  try {
+    const result = await runner.run(command, ["--version"]);
+
+    if (result.exitCode === 0) {
+      return {
+        status: "installed",
+        message: formatInstalledMessage(command, result.stdout),
+      };
+    }
+
+    if (isMissingExit(result.exitCode, result.stderr)) {
+      return {
+        status: "missing",
+        message: `Claude Code command not found: ${command}`,
+      };
+    }
+
+    return {
+      status: "unknown",
+      message: `Claude Code detection returned exit code ${result.exitCode}`,
+    };
+  } catch (error) {
+    if (isCommandMissingError(error)) {
+      return {
+        status: "missing",
+        message: `Claude Code command not found: ${command}`,
+      };
+    }
+
+    return {
+      status: "unknown",
+      message: `Claude Code detection failed: ${describeError(error)}`,
+    };
+  }
+}
+
+class NodeClaudeCommandRunner implements ClaudeCommandRunner {
+  async run(command: string, args: string[]): Promise<ClaudeCommandResult> {
+    return runNodeCommand(command, args);
+  }
+}
+
+function formatInstalledMessage(command: string, stdout?: string): string {
+  const version = stdout?.trim();
+
+  if (version) {
+    return `Claude Code available: ${version}`;
+  }
+
+  return `Claude Code available: ${command}`;
+}
+
+function isMissingExit(exitCode: number, stderr?: string): boolean {
+  if (exitCode === 127) {
+    return true;
+  }
+
+  const normalized = stderr?.toLowerCase() ?? "";
+  return normalized.includes("command not found") || normalized.includes("not recognized");
+}
+
+function isCommandMissingError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    ("code" in error
+      ? (error as NodeJS.ErrnoException).code === "ENOENT"
+      : error.message.includes("ENOENT"))
+  );
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}