@evo-dev/evodev 0.0.1-alpha

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

@@ -0,0 +1,513 @@
+import { constants } from "node:fs";
+import { access, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type {
+  CodeAgentCapabilities,
+  CodeAgentPlugin,
+  DoctorCheck,
+  DoctorContext,
+  PluginDetectionResult,
+  PluginInstallInput,
+  PluginInstallResult,
+  SyncAgentsInput,
+  SyncResult,
+  SyncSkillsInput,
+} from "@evo-dev/core/plugins";
+import { runNodeCommand } from "./command-runner.ts";
+import { type ClaudeCommandRunner, detectClaudeCode } from "./detect.ts";
+import {
+  type ClaudePaths,
+  resolveClaudeAgentTargetPath,
+  resolveClaudePaths,
+  resolveClaudeSkillTargetPath,
+} from "./paths.ts";
+import { transformClaudeAgent } from "./transform-agent.ts";
+import { transformClaudeSkill } from "./transform-skill.ts";
+
+export interface ClaudePathAccessResult {
+  exists: boolean;
+  writable: boolean;
+  checkedPath: string;
+  message?: string;
+}
+
+export interface ClaudePathAccess {
+  checkWritableDirectory(path: string): Promise<ClaudePathAccessResult>;
+}
+
+export interface ClaudeSyncFileSystem {
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  fileExists(path: string): Promise<boolean>;
+  ensureDir(path: string): Promise<void>;
+}
+
+export interface ClaudePluginOptions {
+  commandRunner?: ClaudeCommandRunner;
+  pathAccess?: ClaudePathAccess;
+  syncFileSystem?: ClaudeSyncFileSystem;
+  paths?: ClaudePaths;
+  resolvePaths?: (context: DoctorContext) => ClaudePaths;
+  pluginSelector?: string;
+  pluginMarketplaceSource?: string;
+  pluginScope?: "user";
+}
+
+export function createClaudePlugin(options: ClaudePluginOptions = {}): CodeAgentPlugin {
+  const syncFileSystem = options.syncFileSystem ?? nodeSyncFileSystem;
+  const getSyncPaths = () => options.paths ?? resolveClaudePathsFromHome();
+
+  return {
+    id: "claude",
+    name: "Claude Code",
+    async detect(): Promise<PluginDetectionResult> {
+      return detectClaudeCode({ commandRunner: options.commandRunner });
+    },
+    async getCapabilities(): Promise<CodeAgentCapabilities> {
+      return {
+        skills: { supported: true, format: "claude-skill" },
+        agents: { supported: true, format: "claude-agent" },
+        hooks: {
+          supported: true,
+          events: [
+            "SessionStart",
+            "UserPromptSubmit",
+            "UserPromptExpansion",
+            "PreToolUse",
+            "PermissionRequest",
+            "PostToolUse",
+            "PostToolUseFailure",
+            "PostToolBatch",
+            "PermissionDenied",
+            "SubagentStart",
+            "Stop",
+            "StopFailure",
+            "TeammateIdle",
+            "SubagentStop",
+            "TaskCreated",
+            "TaskCompleted",
+            "PreCompact",
+            "PostCompact",
+            "SessionEnd",
+          ],
+        },
+      };
+    },
+    async doctor(context: DoctorContext): Promise<DoctorCheck[]> {
+      const detection = await detectClaudeCode({ commandRunner: options.commandRunner });
+      const paths =
+        options.resolvePaths?.(context) ?? resolveClaudePaths({ homeDir: context.homeDir });
+      const pathAccess = options.pathAccess ?? nodePathAccess;
+      const [claudeDir, skillsDir, agentsDir] = await Promise.all([
+        pathAccess.checkWritableDirectory(paths.claudeDir),
+        pathAccess.checkWritableDirectory(paths.skillsDir),
+        pathAccess.checkWritableDirectory(paths.agentsDir),
+      ]);
+
+      return [
+        detectionToDoctorCheck(detection),
+        pathAccessToDoctorCheck(
+          "claude.paths.home",
+          "Claude user directory",
+          paths.claudeDir,
+          claudeDir,
+        ),
+        pathAccessToDoctorCheck(
+          "claude.paths.skills",
+          "Claude skills directory",
+          paths.skillsDir,
+          skillsDir,
+        ),
+        pathAccessToDoctorCheck(
+          "claude.paths.agents",
+          "Claude agents directory",
+          paths.agentsDir,
+          agentsDir,
+        ),
+      ];
+    },
+    async syncSkills(input: SyncSkillsInput): Promise<SyncResult> {
+      return syncClaudeSkills(input, getSyncPaths(), syncFileSystem);
+    },
+    async syncAgents(input: SyncAgentsInput): Promise<SyncResult> {
+      return syncClaudeAgents(input, getSyncPaths(), syncFileSystem);
+    },
+    async installPlugin(input: PluginInstallInput): Promise<PluginInstallResult> {
+      return installClaudeCodePlugin(input, options);
+    },
+  };
+}
+
+const nodeSyncFileSystem: ClaudeSyncFileSystem = {
+  async readFile(path: string): Promise<string> {
+    return readFile(path, "utf8");
+  },
+  async writeFile(path: string, content: string): Promise<void> {
+    await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+  },
+  async fileExists(path: string): Promise<boolean> {
+    try {
+      const fileStat = await stat(path);
+      return fileStat.isFile();
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+
+      throw error;
+    }
+  },
+  async ensureDir(path: string): Promise<void> {
+    await mkdir(path, { recursive: true });
+  },
+};
+
+const nodePathAccess: ClaudePathAccess = {
+  async checkWritableDirectory(path: string): Promise<ClaudePathAccessResult> {
+    return checkWritableDirectoryWithoutCreating(path);
+  },
+};
+
+export const claudePlugin = createClaudePlugin();
+
+async function installClaudeCodePlugin(
+  input: PluginInstallInput,
+  options: Pick<
+    ClaudePluginOptions,
+    "commandRunner" | "pluginSelector" | "pluginMarketplaceSource" | "pluginScope"
+  >,
+): Promise<PluginInstallResult> {
+  const command = "claude";
+  const selector = options.pluginSelector ?? "evodev@evo-dev";
+  const scope = options.pluginScope ?? "user";
+  const args = ["plugin", "install", selector, "--scope", scope];
+  const runner = options.commandRunner ?? new NodeClaudeCommandRunner();
+
+  try {
+    if (options.pluginMarketplaceSource !== undefined) {
+      const marketplaceResult = await runner.run(command, [
+        "plugin",
+        "marketplace",
+        "add",
+        options.pluginMarketplaceSource,
+        "--scope",
+        scope,
+      ]);
+      if (marketplaceResult.exitCode !== 0) {
+        return createPluginInstallResult(
+          input.targetPlugin,
+          "failed",
+          command,
+          args,
+          marketplaceResult.stderr ??
+            marketplaceResult.stdout ??
+            `Claude Code marketplace add exited with code ${marketplaceResult.exitCode}`,
+        );
+      }
+    }
+
+    const result = await runner.run(command, args);
+    if (result.exitCode === 0) {
+      if (isAlreadyInstalledMessage(result.stdout ?? result.stderr)) {
+        return createPluginInstallResult(
+          input.targetPlugin,
+          "already-installed",
+          command,
+          args,
+          result.stdout,
+          [
+            "Claude Code reported the plugin is already installed; if local plugin files changed without a version bump, Claude may keep the existing cached copy. Bump the plugin version or uninstall and reinstall to refresh the cache.",
+          ],
+        );
+      }
+
+      return createPluginInstallResult(
+        input.targetPlugin,
+        "installed",
+        command,
+        args,
+        result.stdout,
+      );
+    }
+
+    return createPluginInstallResult(
+      input.targetPlugin,
+      "failed",
+      command,
+      args,
+      result.stderr ??
+        result.stdout ??
+        `Claude Code plugin install exited with code ${result.exitCode}`,
+    );
+  } catch (error) {
+    return createPluginInstallResult(
+      input.targetPlugin,
+      "failed",
+      command,
+      args,
+      describeError(error),
+    );
+  }
+}
+
+function isAlreadyInstalledMessage(message: string | undefined): boolean {
+  return message !== undefined && /already\s+installed/i.test(message);
+}
+
+class NodeClaudeCommandRunner implements ClaudeCommandRunner {
+  async run(
+    command: string,
+    args: string[],
+  ): Promise<{ exitCode: number; stdout?: string; stderr?: string }> {
+    return runNodeCommand(command, args);
+  }
+}
+
+async function checkWritableDirectoryWithoutCreating(
+  path: string,
+): Promise<ClaudePathAccessResult> {
+  const existingPath = await findNearestExistingPath(path);
+
+  if (!existingPath) {
+    return {
+      exists: false,
+      writable: false,
+      checkedPath: path,
+      message: "No existing parent directory found.",
+    };
+  }
+
+  const existingStat = await stat(existingPath);
+  if (!existingStat.isDirectory()) {
+    return {
+      exists: existingPath === path,
+      writable: false,
+      checkedPath: existingPath,
+      message: "Existing path is not a directory.",
+    };
+  }
+
+  try {
+    await access(existingPath, constants.W_OK);
+  } catch (error) {
+    return {
+      exists: existingPath === path,
+      writable: false,
+      checkedPath: existingPath,
+      message: describeError(error),
+    };
+  }
+
+  return {
+    exists: existingPath === path,
+    writable: true,
+    checkedPath: existingPath,
+  };
+}
+
+async function findNearestExistingPath(path: string): Promise<string | null> {
+  let current = path;
+
+  while (true) {
+    try {
+      await stat(current);
+      return current;
+    } catch (error) {
+      if (!isNotFoundError(error) && !isNotDirectoryError(error)) {
+        throw error;
+      }
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function detectionToDoctorCheck(detection: PluginDetectionResult): DoctorCheck {
+  if (detection.status === "installed") {
+    return { id: "claude.available", status: "pass", message: detection.message };
+  }
+
+  if (detection.status === "missing") {
+    return { id: "claude.available", status: "warn", message: detection.message };
+  }
+
+  return { id: "claude.available", status: "warn", message: detection.message };
+}
+
+function pathAccessToDoctorCheck(
+  id: string,
+  label: string,
+  targetPath: string,
+  result: ClaudePathAccessResult,
+): DoctorCheck {
+  if (result.exists && result.writable) {
+    return {
+      id,
+      status: "pass",
+      message: `${label} is writable: ${targetPath}`,
+    };
+  }
+
+  if (!result.exists && result.writable) {
+    return {
+      id,
+      status: "pass",
+      message: `${label} can be created under writable parent: ${result.checkedPath}`,
+    };
+  }
+
+  return {
+    id,
+    status: "fail",
+    message: `${label} is not writable: ${targetPath}${result.message ? ` (${result.message})` : ""}`,
+  };
+}
+
+async function syncClaudeSkills(
+  input: SyncSkillsInput,
+  paths: ClaudePaths,
+  fileSystem: ClaudeSyncFileSystem,
+): Promise<SyncResult> {
+  const result = createEmptySyncResult(input.targetPlugin);
+
+  for (const asset of input.skills) {
+    if (!asset.manifest.targets.includes("claude")) {
+      result.skipped.push(asset.registryKey);
+      continue;
+    }
+
+    try {
+      const source = await fileSystem.readFile(asset.entryPath);
+      const transformed = transformClaudeSkill({ asset, source });
+      const targetPath = resolveClaudeSkillTargetPath(transformed.name, paths);
+
+      if (await fileSystem.fileExists(targetPath)) {
+        result.skipped.push(asset.registryKey);
+        result.warnings.push(`Skipped existing Claude skill target: ${targetPath}`);
+        continue;
+      }
+
+      if (!input.dryRun) {
+        await fileSystem.ensureDir(dirname(targetPath));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+      }
+
+      result.syncedSkills.push(asset.registryKey);
+    } catch (error) {
+      result.errors.push(
+        `Failed to sync Claude skill ${asset.registryKey}: ${describeError(error)}`,
+      );
+    }
+  }
+
+  return result;
+}
+
+async function syncClaudeAgents(
+  input: SyncAgentsInput,
+  paths: ClaudePaths,
+  fileSystem: ClaudeSyncFileSystem,
+): Promise<SyncResult> {
+  const result = createEmptySyncResult(input.targetPlugin);
+
+  for (const asset of input.agents) {
+    if (!asset.manifest.targets.includes("claude")) {
+      result.skipped.push(asset.registryKey);
+      continue;
+    }
+
+    try {
+      const source = await fileSystem.readFile(asset.entryPath);
+      const transformed = transformClaudeAgent({ asset, source });
+      const targetPath = resolveClaudeAgentTargetPath(transformed.name, paths);
+
+      if (await fileSystem.fileExists(targetPath)) {
+        result.skipped.push(asset.registryKey);
+        result.warnings.push(`Skipped existing Claude agent target: ${targetPath}`);
+        continue;
+      }
+
+      if (!input.dryRun) {
+        await fileSystem.ensureDir(dirname(targetPath));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+      }
+
+      result.syncedAgents.push(asset.registryKey);
+    } catch (error) {
+      result.errors.push(
+        `Failed to sync Claude agent ${asset.registryKey}: ${describeError(error)}`,
+      );
+    }
+  }
+
+  return result;
+}
+
+function createEmptySyncResult(targetPlugin: string): SyncResult {
+  return {
+    targetPlugin,
+    syncedSkills: [],
+    syncedAgents: [],
+    skipped: [],
+    warnings: [],
+    errors: [],
+  };
+}
+
+function createPluginInstallResult(
+  targetPlugin: string,
+  status: PluginInstallResult["status"],
+  command: string,
+  args: string[],
+  message?: string,
+  warnings: string[] = [],
+): PluginInstallResult {
+  const normalizedMessage = message?.trim() || `${command} ${args.join(" ")}`;
+  return {
+    targetPlugin,
+    status,
+    command,
+    args,
+    message: normalizedMessage,
+    warnings,
+    errors: status === "failed" ? [normalizedMessage] : [],
+  };
+}
+
+function resolveClaudePathsFromHome(): ClaudePaths {
+  const home = process.env.HOME;
+
+  if (home === undefined || home.trim() === "") {
+    throw new Error("Cannot resolve Claude paths: HOME is not set");
+  }
+
+  return resolveClaudePaths({ homeDir: home });
+}
+
+function ensureTrailingNewline(content: string): string {
+  return content.endsWith("\n") ? content : `${content}\n`;
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+function isNotDirectoryError(error: unknown): boolean {
+  return (
+    error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOTDIR"
+  );
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}

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

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+import {
+  createCoreConfigStore,
+  createDefaultSettings,
+  formatHookRuntimeOutput,
+  handleHookRuntime,
+} from "@evo-dev/core";
+import { normalizeClaudeRuntimeHookPayload, normalizeCodexRuntimeHookPayload } from "./hooks.ts";
+
+export interface HookRuntimeCliOptions {
+  argv?: string[];
+  homeDir?: string;
+  stdin?: string | (() => Promise<string>);
+  write?: (message: string) => void;
+}
+
+export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Promise<number> {
+  const argv = options.argv ?? process.argv.slice(2);
+  const write = options.write ?? process.stdout.write.bind(process.stdout);
+
+  if (argv[0] !== "hook" || argv[1] !== "runtime") {
+    throw new Error(`Unknown plugin command: ${argv.join(" ")}`.trim());
+  }
+
+  const flags = parseHookRuntimeFlags(argv.slice(2));
+  if (flags.target !== "claude" && flags.target !== "codex") {
+    throw new Error(`Unsupported hook target: ${flags.target}`);
+  }
+
+  const homeDir = options.homeDir ?? process.env.HOME ?? "~";
+  const payload = JSON.parse(await readHookRuntimeStdin(options.stdin)) as Record<string, unknown>;
+  const settings = await readHookSettings(homeDir);
+  const event =
+    flags.target === "codex"
+      ? normalizeCodexRuntimeHookPayload({
+          payload,
+          receivedAt: new Date().toISOString(),
+        })
+      : normalizeClaudeRuntimeHookPayload({
+          payload,
+          receivedAt: new Date().toISOString(),
+        });
+  const result = await handleHookRuntime({
+    target: flags.target,
+    homeDir,
+    settings: settings.hooks,
+    event,
+    rawPayload: payload,
+    receivedAt: event.time.receivedAt,
+  });
+  const formatted = formatHookRuntimeOutput(result);
+  if (formatted.length > 0) write(formatted);
+  return 0;
+}
+
+function parseHookRuntimeFlags(argv: string[]): { target: string } {
+  let target: string | undefined;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--target") {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error("Missing value for --target");
+      }
+      target = value;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown hook runtime option: ${arg}`);
+  }
+  if (target === undefined) throw new Error("Missing required --target <target>");
+  return { target };
+}
+
+async function readHookRuntimeStdin(stdin: HookRuntimeCliOptions["stdin"]): Promise<string> {
+  if (typeof stdin === "string") return stdin;
+  if (typeof stdin === "function") return stdin();
+
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function readHookSettings(homeDir: string) {
+  try {
+    return await createCoreConfigStore(homeDir).readSettings();
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return createDefaultSettings();
+    }
+    throw error;
+  }
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (("code" in error && (error as NodeJS.ErrnoException).code === "ENOENT") ||
+      error.message.includes("ENOENT"))
+  );
+}
+
+if (import.meta.main) {
+  try {
+    process.exitCode = await runHookRuntimeCli();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/dist/plugins/evodev/hooks/transform-agent.ts

@@ -0,0 +1,30 @@
+import type { AgentManifest, ScannedAsset } from "@evo-dev/core/assets";
+
+export interface ClaudeAgentTransformInput {
+  asset: ScannedAsset<AgentManifest>;
+  source: string;
+}
+
+export interface ClaudeAgentTransformResult {
+  name: string;
+  content: string;
+}
+
+export function transformClaudeAgent(input: ClaudeAgentTransformInput): ClaudeAgentTransformResult {
+  const { manifest } = input.asset;
+  const frontmatter = [
+    "---",
+    `name: ${manifest.id}`,
+    `description: ${escapeFrontmatterValue(manifest.description)}`,
+    "---",
+  ].join("\n");
+
+  return {
+    name: manifest.id,
+    content: `${frontmatter}\n\n${input.source}`,
+  };
+}
+
+function escapeFrontmatterValue(value: string): string {
+  return value.replaceAll("\n", " ");
+}

package/dist/plugins/evodev/hooks/transform-skill.ts

@@ -0,0 +1,18 @@
+import type { ScannedAsset, SkillManifest } from "@evo-dev/core/assets";
+
+export interface ClaudeSkillTransformInput {
+  asset: ScannedAsset<SkillManifest>;
+  source: string;
+}
+
+export interface ClaudeSkillTransformResult {
+  name: string;
+  content: string;
+}
+
+export function transformClaudeSkill(input: ClaudeSkillTransformInput): ClaudeSkillTransformResult {
+  return {
+    name: input.asset.manifest.id,
+    content: input.source,
+  };
+}

package/dist/plugins/evodev/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@evo-dev/plugin",
+  "version": "0.0.1-alpha",
+  "type": "module",
+  "exports": {
+    ".": "./hooks/index.ts"
+  },
+  "dependencies": {
+    "@evo-dev/core": "0.0.1-alpha"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "files": ["hooks", ".claude-plugin", ".codex-plugin", "hooks", "package.json"],
+  "license": "MIT"
+}