@evo-dev/evodev 0.0.1-alpha → 0.0.1-alpha.10

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

@@ -23,6 +23,11 @@ import {
 } from "./paths.ts";
 import { transformClaudeAgent } from "./transform-agent.ts";
 import { transformClaudeSkill } from "./transform-skill.ts";
+import {
+  type WorkspaceCoreHydrationResult,
+  hydrateWorkspaceCoreDependency,
+  isSafePluginCacheSegment,
+} from "./workspace-core.ts";
 
 export interface ClaudePathAccessResult {
   exists: boolean;
@@ -37,7 +42,7 @@ export interface ClaudePathAccess {
 
 export interface ClaudeSyncFileSystem {
   readFile(path: string): Promise<string>;
-  writeFile(path: string, content: string): Promise<void>;
+  writeFile(path: string, content: string, options?: { overwrite?: boolean }): Promise<void>;
   fileExists(path: string): Promise<boolean>;
   ensureDir(path: string): Promise<void>;
 }
@@ -142,8 +147,15 @@ 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 writeFile(
+    path: string,
+    content: string,
+    options: { overwrite?: boolean } = {},
+  ): Promise<void> {
+    await writeFile(path, content, {
+      encoding: "utf8",
+      flag: options.overwrite === true ? "w" : "wx",
+    });
   },
   async fileExists(path: string): Promise<boolean> {
     try {
@@ -174,7 +186,7 @@ async function installClaudeCodePlugin(
   input: PluginInstallInput,
   options: Pick<
     ClaudePluginOptions,
-    "commandRunner" | "pluginSelector" | "pluginMarketplaceSource" | "pluginScope"
+    "commandRunner" | "paths" | "pluginSelector" | "pluginMarketplaceSource" | "pluginScope"
   >,
 ): Promise<PluginInstallResult> {
   const command = "claude";
@@ -182,6 +194,7 @@ async function installClaudeCodePlugin(
   const scope = options.pluginScope ?? "user";
   const args = ["plugin", "install", selector, "--scope", scope];
   const runner = options.commandRunner ?? new NodeClaudeCommandRunner();
+  const warnings: string[] = [];
 
   try {
     if (options.pluginMarketplaceSource !== undefined) {
@@ -204,10 +217,73 @@ async function installClaudeCodePlugin(
             `Claude Code marketplace add exited with code ${marketplaceResult.exitCode}`,
         );
       }
+
+      const marketplaceName = extractMarketplaceNameFromSelector(selector);
+      if (marketplaceName === undefined) {
+        warnings.push(
+          `Skipped Claude Code marketplace update because selector does not include a marketplace name: ${selector}`,
+        );
+      } else {
+        const updateResult = await runner.run(command, [
+          "plugin",
+          "marketplace",
+          "update",
+          marketplaceName,
+        ]);
+        if (updateResult.exitCode !== 0) {
+          return createPluginInstallResult(
+            input.targetPlugin,
+            "failed",
+            command,
+            args,
+            updateResult.stderr ??
+              updateResult.stdout ??
+              `Claude Code marketplace update exited with code ${updateResult.exitCode}`,
+          );
+        }
+      }
+    }
+
+    if (input.force === true) {
+      const uninstallArgs = [
+        "plugin",
+        "uninstall",
+        selector,
+        "--scope",
+        scope,
+        "--keep-data",
+        "-y",
+      ];
+      const uninstallResult = await runner.run(command, uninstallArgs);
+      const uninstallMessage = uninstallResult.stderr ?? uninstallResult.stdout;
+      if (uninstallResult.exitCode !== 0 && !isNotInstalledMessage(uninstallMessage)) {
+        warnings.push(
+          `Claude Code plugin refresh uninstall did not complete: ${
+            uninstallMessage ??
+            `Claude Code plugin uninstall exited with code ${uninstallResult.exitCode}`
+          }`,
+        );
+      }
     }
 
     const result = await runner.run(command, args);
     if (result.exitCode === 0) {
+      const hydration = await hydrateClaudeWorkspaceCoreDependency({
+        paths: options.paths,
+        selector,
+      });
+      warnings.push(...hydration.warnings);
+      if (hydration.errors.length > 0) {
+        return createPluginInstallResult(
+          input.targetPlugin,
+          "failed",
+          command,
+          args,
+          hydration.errors.join("\n"),
+          warnings,
+        );
+      }
+
       if (isAlreadyInstalledMessage(result.stdout ?? result.stderr)) {
         return createPluginInstallResult(
           input.targetPlugin,
@@ -216,7 +292,10 @@ async function installClaudeCodePlugin(
           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.",
+            ...warnings,
+            input.force === true
+              ? "Claude Code reported the plugin is already installed after forced refresh; check the local plugin cache if changes are not visible."
+              : "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.",
           ],
         );
       }
@@ -227,6 +306,7 @@ async function installClaudeCodePlugin(
         command,
         args,
         result.stdout,
+        warnings,
       );
     }
 
@@ -254,6 +334,61 @@ function isAlreadyInstalledMessage(message: string | undefined): boolean {
   return message !== undefined && /already\s+installed/i.test(message);
 }
 
+function isNotInstalledMessage(message: string | undefined): boolean {
+  return message !== undefined && /(not\s+installed|not\s+found|no\s+installed)/i.test(message);
+}
+
+function extractMarketplaceNameFromSelector(selector: string): string | undefined {
+  const separator = selector.lastIndexOf("@");
+  if (separator <= 0 || separator === selector.length - 1) return undefined;
+  return selector.slice(separator + 1);
+}
+
+function extractPluginNameFromSelector(selector: string): string | undefined {
+  const separator = selector.lastIndexOf("@");
+  const pluginName = separator <= 0 ? selector : selector.slice(0, separator);
+  return pluginName.trim() === "" ? undefined : pluginName;
+}
+
+async function hydrateClaudeWorkspaceCoreDependency(input: {
+  paths?: ClaudePaths;
+  selector: string;
+}): Promise<WorkspaceCoreHydrationResult> {
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  if (input.paths === undefined) {
+    return { warnings, errors };
+  }
+
+  const marketplaceName = extractMarketplaceNameFromSelector(input.selector);
+  const pluginName = extractPluginNameFromSelector(input.selector);
+  if (marketplaceName === undefined || pluginName === undefined) {
+    warnings.push(
+      `Skipped @evo-dev/core hydration because Claude plugin selector is not marketplace-qualified: ${input.selector}`,
+    );
+    return { warnings, errors };
+  }
+  if (!isSafePluginCacheSegment(marketplaceName) || !isSafePluginCacheSegment(pluginName)) {
+    warnings.push(
+      `Skipped @evo-dev/core hydration because Claude plugin selector contains an unsafe cache segment: ${input.selector}`,
+    );
+    return { warnings, errors };
+  }
+
+  const cachePluginRoot = `${input.paths.claudeDir}/plugins/cache/${marketplaceName}/${pluginName}`;
+  const marketplaceCoreRoot = `${input.paths.claudeDir}/plugins/marketplaces/${marketplaceName}/packages/core`;
+  const hydration = await hydrateWorkspaceCoreDependency({
+    sourceCoreRoot: marketplaceCoreRoot,
+    cachePluginRoot,
+    runtimeLabel: "Claude",
+  });
+  return {
+    warnings: [...warnings, ...hydration.warnings],
+    errors: [...errors, ...hydration.errors],
+  };
+}
+
 class NodeClaudeCommandRunner implements ClaudeCommandRunner {
   async run(
     command: string,
@@ -384,8 +519,9 @@ async function syncClaudeSkills(
       const source = await fileSystem.readFile(asset.entryPath);
       const transformed = transformClaudeSkill({ asset, source });
       const targetPath = resolveClaudeSkillTargetPath(transformed.name, paths);
+      const targetExists = await fileSystem.fileExists(targetPath);
 
-      if (await fileSystem.fileExists(targetPath)) {
+      if (targetExists && input.force !== true) {
         result.skipped.push(asset.registryKey);
         result.warnings.push(`Skipped existing Claude skill target: ${targetPath}`);
         continue;
@@ -393,9 +529,16 @@ async function syncClaudeSkills(
 
       if (!input.dryRun) {
         await fileSystem.ensureDir(dirname(targetPath));
-        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content), {
+          overwrite: input.force === true,
+        });
       }
 
+      if (targetExists) {
+        result.warnings.push(
+          `${input.dryRun ? "Would update" : "Updated"} existing Claude skill target: ${targetPath}`,
+        );
+      }
       result.syncedSkills.push(asset.registryKey);
     } catch (error) {
       result.errors.push(
@@ -424,8 +567,9 @@ async function syncClaudeAgents(
       const source = await fileSystem.readFile(asset.entryPath);
       const transformed = transformClaudeAgent({ asset, source });
       const targetPath = resolveClaudeAgentTargetPath(transformed.name, paths);
+      const targetExists = await fileSystem.fileExists(targetPath);
 
-      if (await fileSystem.fileExists(targetPath)) {
+      if (targetExists && input.force !== true) {
         result.skipped.push(asset.registryKey);
         result.warnings.push(`Skipped existing Claude agent target: ${targetPath}`);
         continue;
@@ -433,9 +577,16 @@ async function syncClaudeAgents(
 
       if (!input.dryRun) {
         await fileSystem.ensureDir(dirname(targetPath));
-        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content), {
+          overwrite: input.force === true,
+        });
       }
 
+      if (targetExists) {
+        result.warnings.push(
+          `${input.dryRun ? "Would update" : "Updated"} existing Claude agent target: ${targetPath}`,
+        );
+      }
       result.syncedAgents.push(asset.registryKey);
     } catch (error) {
       result.errors.push(

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

@@ -1,57 +1,122 @@
 #!/usr/bin/env bun
 
-import {
-  createCoreConfigStore,
-  createDefaultSettings,
-  formatHookRuntimeOutput,
-  handleHookRuntime,
-} from "@evo-dev/core";
-import { normalizeClaudeRuntimeHookPayload, normalizeCodexRuntimeHookPayload } from "./hooks.ts";
+import type { HookEventV1, HookRuntimeResult } from "@evo-dev/core";
+
+export type HookRuntimeCoreApi = typeof import("@evo-dev/core");
+export type HookRuntimeNormalizerApi = typeof import("./hooks.ts");
+
+export interface HookRuntimeApi {
+  core: HookRuntimeCoreApi;
+  normalizers: HookRuntimeNormalizerApi;
+}
 
 export interface HookRuntimeCliOptions {
   argv?: string[];
+  environment?: Record<string, string | undefined>;
   homeDir?: string;
+  loadRuntimeApi?: () => Promise<HookRuntimeApi>;
   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 environment = options.environment ?? process.env;
   const write = options.write ?? process.stdout.write.bind(process.stdout);
+  const startedAt = new Date();
+  const loadRuntimeApi = options.loadRuntimeApi ?? loadDefaultHookRuntimeApi;
+  let homeDir = options.homeDir ?? process.env.HOME ?? "~";
+  let runtimeApi: HookRuntimeApi | null = null;
+  let target = "unknown";
+  let payload: Record<string, unknown> | null = null;
+  let stdinBytes: number | null = null;
 
-  if (argv[0] !== "hook" || argv[1] !== "runtime") {
-    throw new Error(`Unknown plugin command: ${argv.join(" ")}`.trim());
-  }
+  try {
+    if (argv[0] !== "hook" || argv[1] !== "runtime") {
+      throw new Error(`Unknown plugin command: ${argv.join(" ")}`.trim());
+    }
+
+    const flags = parseHookRuntimeFlags(argv.slice(2));
+    target = flags.target;
+    if (flags.target !== "claude" && flags.target !== "codex") {
+      throw new Error(`Unsupported hook target: ${flags.target}`);
+    }
+
+    homeDir = options.homeDir ?? process.env.HOME ?? "~";
+    const stdin = await readHookRuntimeStdin(options.stdin);
+    stdinBytes = Buffer.byteLength(stdin, "utf8");
+    runtimeApi = await loadRuntimeApi();
+    payload = JSON.parse(stdin) as Record<string, unknown>;
+    await appendExecutionEventSafely({
+      core: runtimeApi.core,
+      homeDir,
+      phase: "started",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      environment,
+    });
 
-  const flags = parseHookRuntimeFlags(argv.slice(2));
-  if (flags.target !== "claude" && flags.target !== "codex") {
-    throw new Error(`Unsupported hook target: ${flags.target}`);
+    const settings = await readHookSettings(runtimeApi.core, homeDir);
+    const event =
+      flags.target === "codex"
+        ? runtimeApi.normalizers.normalizeCodexRuntimeHookPayload({
+            payload,
+            receivedAt: new Date().toISOString(),
+          })
+        : runtimeApi.normalizers.normalizeClaudeRuntimeHookPayload({
+            payload,
+            receivedAt: new Date().toISOString(),
+          });
+    const result = await runtimeApi.core.handleHookRuntime({
+      target: flags.target,
+      homeDir,
+      settings: settings.hooks,
+      teamRuntimeDisplayMode: settings.teamRuntime.displayMode,
+      event,
+      rawPayload: payload,
+      receivedAt: event.time.receivedAt,
+      environment,
+      runtimeInjectionEnabled: settings.memory.runtimeInjection,
+      sessionMemoryPolicy: settings.memory.sessionMemory,
+    });
+    const formatted = runtimeApi.core.formatHookRuntimeOutput(result);
+    await appendExecutionEventSafely({
+      core: runtimeApi.core,
+      homeDir,
+      phase: "completed",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      event,
+      result,
+      environment,
+      durationMs: Date.now() - startedAt.getTime(),
+    });
+    if (formatted.length > 0) write(formatted);
+    return 0;
+  } catch (error) {
+    await appendExecutionEventSafely({
+      core: runtimeApi?.core,
+      homeDir,
+      phase: "failed",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      error,
+      environment,
+      durationMs: Date.now() - startedAt.getTime(),
+    });
+    return 0;
   }
+}
 
-  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;
+async function loadDefaultHookRuntimeApi(): Promise<HookRuntimeApi> {
+  const [core, normalizers] = await Promise.all([import("@evo-dev/core"), import("./hooks.ts")]);
+  return { core, normalizers };
 }
 
 function parseHookRuntimeFlags(argv: string[]): { target: string } {
@@ -84,17 +149,144 @@ async function readHookRuntimeStdin(stdin: HookRuntimeCliOptions["stdin"]): Prom
   return Buffer.concat(chunks).toString("utf8");
 }
 
-async function readHookSettings(homeDir: string) {
+async function readHookSettings(core: HookRuntimeCoreApi, homeDir: string) {
   try {
-    return await createCoreConfigStore(homeDir).readSettings();
+    return await core.createCoreConfigStore(homeDir).readSettings();
   } catch (error) {
     if (isNotFoundError(error)) {
-      return createDefaultSettings();
+      return core.createDefaultSettings();
     }
-    throw error;
+    return core.createDefaultSettings();
   }
 }
 
+async function appendExecutionEventSafely(input: {
+  core?: HookRuntimeCoreApi;
+  homeDir: string;
+  phase: "started" | "completed" | "failed";
+  target: string;
+  argv: string[];
+  payload: Record<string, unknown> | null;
+  stdinBytes: number | null;
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  durationMs?: number | null;
+  error?: unknown;
+  environment?: Record<string, string | undefined>;
+}): Promise<void> {
+  if (input.core === undefined) return;
+
+  try {
+    const sessionKey =
+      input.payload === null ? "session-local" : input.core.resolveTraceSessionKey(input.payload);
+    const team = input.core.resolveTraceTeamContext({
+      homeDir: input.homeDir,
+      environment: input.environment,
+      payload: input.payload,
+    });
+    const cwd =
+      input.payload !== null && typeof input.payload.cwd === "string" ? input.payload.cwd : null;
+    const workspace =
+      team === null && cwd !== null
+        ? await input.core.resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd })
+        : null;
+    const traceRefId = await recordTraceRefSafely(input);
+    await input.core.appendEvoDevExecutionEvent(
+      input.homeDir,
+      input.core.createEvoDevExecutionEvent({
+        eventId: input.event?.eventId,
+        target: input.target,
+        eventType: input.event?.type ?? runtimePhaseEventType(input.phase),
+        sessionKey,
+        projectKey: team?.projectKey ?? workspace?.projectKey ?? null,
+        runId: team?.runId ?? null,
+        roleId: team?.roleId ?? null,
+        taskId: input.event?.scope.taskId ?? null,
+        summary: summarizeExecutionEvent(input),
+        metadata: createExecutionEventMetadata(input),
+        decision: input.event?.decision ?? null,
+        codeAgentTraceRefId: traceRefId,
+      }),
+    );
+  } catch {
+    // Execution event logging must never change hook runtime behavior.
+  }
+}
+
+async function recordTraceRefSafely(input: {
+  core?: HookRuntimeCoreApi;
+  homeDir: string;
+  target: string;
+  payload: Record<string, unknown> | null;
+  event?: HookEventV1;
+  environment?: Record<string, string | undefined>;
+}): Promise<string | null> {
+  if (
+    input.core === undefined ||
+    input.payload === null ||
+    (input.target !== "claude" && input.target !== "codex")
+  ) {
+    return null;
+  }
+  try {
+    const record = await input.core.recordCodeAgentTraceRefFromHook({
+      homeDir: input.homeDir,
+      target: input.target,
+      payload: input.payload,
+      environment: input.environment,
+      now:
+        input.event?.time.receivedAt === undefined || input.event.time.receivedAt === "dry-run"
+          ? undefined
+          : input.event.time.receivedAt,
+    });
+    return record?.ref.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function runtimePhaseEventType(phase: "started" | "completed" | "failed"): string {
+  if (phase === "started") return "HookRuntimeStarted";
+  if (phase === "completed") return "HookRuntimeCompleted";
+  return "HookRuntimeFailed";
+}
+
+function summarizeExecutionEvent(input: {
+  phase: "started" | "completed" | "failed";
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  error?: unknown;
+}): string {
+  if (input.phase === "failed") return "Hook runtime failed before completion.";
+  if (input.result !== undefined) return input.result.summary;
+  if (input.event !== undefined) return input.event.payload.summary;
+  return "Hook runtime started.";
+}
+
+function createExecutionEventMetadata(input: {
+  phase: "started" | "completed" | "failed";
+  stdinBytes: number | null;
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  durationMs?: number | null;
+}): Record<string, unknown> {
+  return {
+    phase: input.phase,
+    runtimeSurface: "plugin",
+    stdinBytes: input.stdinBytes,
+    durationMs: input.durationMs ?? null,
+    enabled: input.result?.enabled,
+    stateWriteCount: input.result?.stateWrites.length,
+    warningCount: input.result?.warnings.length,
+    commandClass: input.event?.payload.metadata.commandClass,
+    exitCode: input.event?.payload.metadata.exitCode,
+    status: input.event?.payload.metadata.status ?? input.phase,
+    redactionCount: input.event?.payload.redactionCount,
+    redactionLabels: input.event?.payload.redactions,
+    normalizedEventType: input.event?.type,
+  };
+}
+
 function isNotFoundError(error: unknown): boolean {
   return (
     error instanceof Error &&
@@ -107,7 +299,6 @@ if (import.meta.main) {
   try {
     process.exitCode = await runHookRuntimeCli();
   } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
+    process.exitCode = 0;
   }
 }

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

@@ -10,6 +10,16 @@ export interface ClaudeAgentTransformResult {
   content: string;
 }
 
+export interface CodexAgentTransformInput {
+  asset: ScannedAsset<AgentManifest>;
+  source: string;
+}
+
+export interface CodexAgentTransformResult {
+  name: string;
+  content: string;
+}
+
 export function transformClaudeAgent(input: ClaudeAgentTransformInput): ClaudeAgentTransformResult {
   const { manifest } = input.asset;
   const frontmatter = [
@@ -25,6 +35,26 @@ export function transformClaudeAgent(input: ClaudeAgentTransformInput): ClaudeAg
   };
 }
 
+export function transformCodexAgent(input: CodexAgentTransformInput): CodexAgentTransformResult {
+  const { manifest } = input.asset;
+  const lines = [
+    `# Generated by EvoDev from ${input.asset.registryKey}`,
+    `name = ${tomlString(manifest.id)}`,
+    `description = ${tomlString(manifest.description)}`,
+    `developer_instructions = ${tomlString(input.source)}`,
+    "",
+  ];
+
+  return {
+    name: manifest.id,
+    content: lines.join("\n"),
+  };
+}
+
 function escapeFrontmatterValue(value: string): string {
   return value.replaceAll("\n", " ");
 }
+
+function tomlString(value: string): string {
+  return JSON.stringify(value);
+}