@codemieai/code 0.0.40 → 0.0.42

package/dist/agents/plugins/codemie-code-hooks/shell-hooks-source.js

@@ -0,0 +1,522 @@
+/**
+ * Shell Hooks Plugin Source
+ *
+ * Contains the OpenCode plugin TypeScript source as a string constant.
+ * At runtime this is written to a temp file and loaded by the OpenCode binary.
+ *
+ * The plugin reads hooks configuration from the OPENCODE_HOOKS environment variable
+ * (Anthropic/Claude Code format) and maps them to OpenCode plugin lifecycle hooks.
+ *
+ * Why a string constant: The plugin uses `import type { Plugin } from "@opencode-ai/plugin"`
+ * which doesn't exist in codemie-code's dependencies. Embedding as a string avoids
+ * TypeScript compilation issues. Bun strips the type import at runtime.
+ */
+export const SHELL_HOOKS_PLUGIN_SOURCE = `
+import type { Plugin } from "@opencode-ai/plugin";
+import { execSync, spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface HookConfig {
+  type: "command" | "prompt" | "agent";
+  command?: string;
+  timeout?: number; // seconds
+  async?: boolean;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks: HookConfig[];
+}
+
+type HookEventName =
+  | "PreToolUse"
+  | "PostToolUse"
+  | "UserPromptSubmit"
+  | "PermissionRequest"
+  | "PreCompact"
+  | "SessionStart"
+  | "SessionEnd"
+  | "Stop"
+  | "Notification";
+
+interface HooksConfig {
+  hooks?: Partial<Record<HookEventName, HookMatcherEntry[]>>;
+}
+
+interface HookStdinPayload {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  permission_mode: string;
+  transcript_path: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_output?: string;
+  prompt?: string;
+  [key: string]: unknown;
+}
+
+// ─── Matcher (ported from codemie-code src/hooks/matcher.ts) ─────────────────
+
+function matchesPattern(pattern: string, toolName: string): boolean {
+  try {
+    if (!pattern || pattern === "*") return true;
+    if (/[|[\\]{}()]/.test(pattern)) {
+      try {
+        return new RegExp("^(" + pattern + ")$").test(toolName);
+      } catch {
+        return pattern === toolName;
+      }
+    }
+    return pattern === toolName;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Config Loading ──────────────────────────────────────────────────────────
+
+function loadHooksConfig(): HooksConfig {
+  // Priority 1: OPENCODE_HOOKS env var (set by codemie-code)
+  const envHooks = process.env.OPENCODE_HOOKS;
+  if (envHooks) {
+    try {
+      const parsed = JSON.parse(envHooks);
+      if (parsed.hooks && Object.keys(parsed.hooks).length > 0) {
+        return parsed as HooksConfig;
+      }
+    } catch {
+      // Fall through to file-based config
+    }
+  }
+
+  // Priority 2: .opencode/hooks.json in project directory
+  const projectDir = process.env.OPENCODE_PROJECT_DIR || process.cwd();
+  const hooksFile = join(projectDir, ".opencode", "hooks.json");
+  if (existsSync(hooksFile)) {
+    try {
+      const content = readFileSync(hooksFile, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.hooks) return parsed as HooksConfig;
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  return { hooks: {} };
+}
+
+// ─── Hook Resolution ─────────────────────────────────────────────────────────
+
+function getMatchingCommands(
+  config: HooksConfig,
+  event: HookEventName,
+  toolName?: string,
+): Array<{ command: string; timeout: number; isAsync: boolean }> {
+  const matchers = config.hooks?.[event];
+  if (!matchers || matchers.length === 0) return [];
+
+  const result: Array<{ command: string; timeout: number; isAsync: boolean }> = [];
+
+  for (const entry of matchers) {
+    const pattern = entry.matcher || "*";
+    const shouldMatch = !toolName || matchesPattern(pattern, toolName);
+    if (!shouldMatch) continue;
+
+    for (const hook of entry.hooks) {
+      // Only support "command" type — skip "prompt" and "agent"
+      if (hook.type !== "command" || !hook.command) continue;
+      result.push({
+        command: hook.command,
+        timeout: (hook.timeout || 60) * 1000, // seconds → ms
+        isAsync: hook.async === true,
+      });
+    }
+  }
+
+  return result;
+}
+
+// ─── Shell Execution ─────────────────────────────────────────────────────────
+
+function buildEnvVars(sessionId: string, event: string): Record<string, string> {
+  const projectDir = process.env.OPENCODE_PROJECT_DIR || process.cwd();
+  return {
+    OPENCODE_PROJECT_DIR: projectDir,
+    OPENCODE_SESSION_ID: sessionId,
+    OPENCODE_HOOK_EVENT: event,
+    CLAUDE_PROJECT_DIR: projectDir, // Anthropic alias
+  };
+}
+
+interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+function execCommand(
+  command: string,
+  stdin: string,
+  env: Record<string, string>,
+  timeout: number,
+): ExecResult {
+  try {
+    const stdout = execSync(command, {
+      input: stdin,
+      timeout,
+      env: { ...process.env, ...env },
+      encoding: "utf-8",
+      maxBuffer: 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { stdout: stdout || "", stderr: "", exitCode: 0 };
+  } catch (err: any) {
+    return {
+      stdout: err.stdout || "",
+      stderr: err.stderr || "",
+      exitCode: typeof err.status === "number" ? err.status : 1,
+    };
+  }
+}
+
+function execCommandAsync(
+  command: string,
+  stdin: string,
+  env: Record<string, string>,
+): void {
+  const child = spawn("sh", ["-c", command], {
+    env: { ...process.env, ...env },
+    stdio: ["pipe", "ignore", "ignore"],
+    detached: true,
+  });
+  if (child.stdin) {
+    child.stdin.write(stdin);
+    child.stdin.end();
+  }
+  child.unref();
+}
+
+// ─── Response Parsing ────────────────────────────────────────────────────────
+
+interface ParsedResponse {
+  blocked: boolean;
+  reason?: string;
+  updatedInput?: Record<string, unknown>;
+  permissionDecision?: "allow" | "deny" | "ask";
+  additionalContext?: string;
+}
+
+function parseResponse(
+  result: ExecResult,
+  event: HookEventName,
+): ParsedResponse {
+  // Exit code 2 = block
+  if (result.exitCode === 2) {
+    const reason = [result.stderr, result.stdout.trim()].filter(Boolean).join("\\n");
+    return { blocked: true, reason: reason || "Hook blocked execution (exit code 2)" };
+  }
+
+  // Non-zero, non-2 = non-blocking error (allow)
+  if (result.exitCode !== 0) {
+    return { blocked: false };
+  }
+
+  // Parse stdout JSON
+  const trimmed = result.stdout.trim();
+  if (!trimmed) return { blocked: false };
+
+  try {
+    const json = JSON.parse(trimmed);
+
+    // PreToolUse: check for hookSpecificOutput.updatedInput or plain object → merge into args
+    if (event === "PreToolUse") {
+      const updated = json.hookSpecificOutput?.updatedInput || json.updatedInput;
+      if (updated && typeof updated === "object") {
+        return { blocked: false, updatedInput: updated };
+      }
+      // If it's a plain object without known keys, treat as updatedInput
+      if (typeof json === "object" && !json.hookSpecificOutput && !json.decision) {
+        return { blocked: false, updatedInput: json };
+      }
+    }
+
+    // PermissionRequest: check for permissionDecision
+    if (event === "PermissionRequest") {
+      const decision =
+        json.hookSpecificOutput?.permissionDecision || json.permissionDecision;
+      if (decision && ["allow", "deny", "ask"].includes(decision)) {
+        return { blocked: false, permissionDecision: decision };
+      }
+      // Plain string
+      if (typeof json === "string" && ["allow", "deny", "ask"].includes(json)) {
+        return { blocked: false, permissionDecision: json };
+      }
+    }
+
+    // PreCompact: additionalContext
+    if (event === "PreCompact") {
+      const context = json.additionalContext || json.context;
+      if (typeof context === "string") {
+        return { blocked: false, additionalContext: context };
+      }
+    }
+
+    return { blocked: false };
+  } catch {
+    // Non-JSON output — treat as informational
+    return { blocked: false };
+  }
+}
+
+// ─── Plugin Definition ───────────────────────────────────────────────────────
+
+const config = loadHooksConfig();
+const hasHooks = config.hooks && Object.keys(config.hooks).length > 0;
+
+const plugin: Plugin = {
+  name: "shell-hooks",
+  ...(hasHooks
+    ? {
+        hooks: {
+          // PreToolUse → tool.execute.before (blocking)
+          tool: {
+            execute: {
+              before: async (input) => {
+                const commands = getMatchingCommands(config, "PreToolUse", input.tool);
+                if (commands.length === 0) return input;
+
+                const sessionId = process.env.OPENCODE_SESSION_ID || "";
+                const env = buildEnvVars(sessionId, "PreToolUse");
+                const payload: HookStdinPayload = {
+                  hook_event_name: "PreToolUse",
+                  session_id: sessionId,
+                  cwd: process.cwd(),
+                  permission_mode: "default",
+                  transcript_path: "",
+                  tool_name: input.tool,
+                  tool_input: input.args as Record<string, unknown>,
+                };
+                const stdin = JSON.stringify(payload);
+
+                let mergedInput = { ...input };
+                for (const cmd of commands) {
+                  if (cmd.isAsync) {
+                    execCommandAsync(cmd.command, stdin, env);
+                    continue;
+                  }
+                  const result = execCommand(cmd.command, stdin, env, cmd.timeout);
+                  const parsed = parseResponse(result, "PreToolUse");
+                  if (parsed.blocked) {
+                    throw new Error(parsed.reason || "Hook blocked tool execution");
+                  }
+                  if (parsed.updatedInput) {
+                    mergedInput = {
+                      ...mergedInput,
+                      args: { ...(mergedInput.args as Record<string, unknown>), ...parsed.updatedInput },
+                    };
+                  }
+                }
+                return mergedInput;
+              },
+
+              // PostToolUse → tool.execute.after (fire-and-forget)
+              after: async (output) => {
+                const commands = getMatchingCommands(config, "PostToolUse", output.tool);
+                if (commands.length === 0) return output;
+
+                const sessionId = process.env.OPENCODE_SESSION_ID || "";
+                const env = buildEnvVars(sessionId, "PostToolUse");
+                const payload: HookStdinPayload = {
+                  hook_event_name: "PostToolUse",
+                  session_id: sessionId,
+                  cwd: process.cwd(),
+                  permission_mode: "default",
+                  transcript_path: "",
+                  tool_name: output.tool,
+                  tool_input: output.args as Record<string, unknown>,
+                  tool_output: typeof output.result === "string" ? output.result : JSON.stringify(output.result),
+                };
+                const stdin = JSON.stringify(payload);
+
+                for (const cmd of commands) {
+                  if (cmd.isAsync) {
+                    execCommandAsync(cmd.command, stdin, env);
+                    continue;
+                  }
+                  try {
+                    execCommand(cmd.command, stdin, env, cmd.timeout);
+                  } catch {
+                    // PostToolUse is fire-and-forget
+                  }
+                }
+                return output;
+              },
+            },
+          },
+
+          // UserPromptSubmit → chat.message (blocking)
+          chat: {
+            message: async (input) => {
+              const commands = getMatchingCommands(config, "UserPromptSubmit");
+              if (commands.length === 0) return input;
+
+              const sessionId = process.env.OPENCODE_SESSION_ID || "";
+              const env = buildEnvVars(sessionId, "UserPromptSubmit");
+              const payload: HookStdinPayload = {
+                hook_event_name: "UserPromptSubmit",
+                session_id: sessionId,
+                cwd: process.cwd(),
+                permission_mode: "default",
+                transcript_path: "",
+                prompt: Array.isArray(input.parts)
+                  ? input.parts
+                      .filter((p: any) => p.type === "text")
+                      .map((p: any) => p.text)
+                      .join("\\n")
+                  : String(input.parts),
+              };
+              const stdin = JSON.stringify(payload);
+
+              for (const cmd of commands) {
+                if (cmd.isAsync) {
+                  execCommandAsync(cmd.command, stdin, env);
+                  continue;
+                }
+                const result = execCommand(cmd.command, stdin, env, cmd.timeout);
+                const parsed = parseResponse(result, "UserPromptSubmit");
+                if (parsed.blocked) {
+                  // Clear message parts to block submission
+                  return { ...input, parts: [] };
+                }
+              }
+              return input;
+            },
+          },
+
+          // PermissionRequest → permission.ask (blocking)
+          permission: {
+            ask: async (input) => {
+              const commands = getMatchingCommands(config, "PermissionRequest", input.tool);
+              if (commands.length === 0) return input;
+
+              const sessionId = process.env.OPENCODE_SESSION_ID || "";
+              const env = buildEnvVars(sessionId, "PermissionRequest");
+              const payload: HookStdinPayload = {
+                hook_event_name: "PermissionRequest",
+                session_id: sessionId,
+                cwd: process.cwd(),
+                permission_mode: "default",
+                transcript_path: "",
+                tool_name: input.tool,
+                tool_input: input.args as Record<string, unknown>,
+              };
+              const stdin = JSON.stringify(payload);
+
+              for (const cmd of commands) {
+                if (cmd.isAsync) {
+                  execCommandAsync(cmd.command, stdin, env);
+                  continue;
+                }
+                const result = execCommand(cmd.command, stdin, env, cmd.timeout);
+                const parsed = parseResponse(result, "PermissionRequest");
+                if (parsed.permissionDecision === "allow") {
+                  return { ...input, allowed: true };
+                }
+                if (parsed.permissionDecision === "deny") {
+                  return { ...input, allowed: false };
+                }
+              }
+              return input;
+            },
+          },
+
+          // PreCompact → experimental.session.compacting (non-blocking)
+          experimental: {
+            session: {
+              compacting: async (input) => {
+                const commands = getMatchingCommands(config, "PreCompact");
+                if (commands.length === 0) return input;
+
+                const sessionId = process.env.OPENCODE_SESSION_ID || "";
+                const env = buildEnvVars(sessionId, "PreCompact");
+                const payload: HookStdinPayload = {
+                  hook_event_name: "PreCompact",
+                  session_id: sessionId,
+                  cwd: process.cwd(),
+                  permission_mode: "default",
+                  transcript_path: "",
+                };
+                const stdin = JSON.stringify(payload);
+
+                for (const cmd of commands) {
+                  if (cmd.isAsync) {
+                    execCommandAsync(cmd.command, stdin, env);
+                    continue;
+                  }
+                  try {
+                    const result = execCommand(cmd.command, stdin, env, cmd.timeout);
+                    const parsed = parseResponse(result, "PreCompact");
+                    if (parsed.additionalContext) {
+                      return {
+                        ...input,
+                        context: ((input as any).context || "") + "\\n" + parsed.additionalContext,
+                      };
+                    }
+                  } catch {
+                    // Non-blocking
+                  }
+                }
+                return input;
+              },
+            },
+          },
+
+          // SessionStart/SessionEnd/Stop/Notification → event (non-blocking)
+          event: async (input) => {
+            let hookEvent: HookEventName | undefined;
+            const eventType = (input as any).type || (input as any).event;
+            if (eventType === "session.created") hookEvent = "SessionStart";
+            else if (eventType === "session.deleted") hookEvent = "SessionEnd";
+            else if (eventType === "session.idle") hookEvent = "Stop";
+            else if (eventType === "session.error") hookEvent = "Notification";
+
+            if (!hookEvent) return;
+
+            const commands = getMatchingCommands(config, hookEvent);
+            if (commands.length === 0) return;
+
+            const sessionId = process.env.OPENCODE_SESSION_ID || "";
+            const env = buildEnvVars(sessionId, hookEvent);
+            const payload: HookStdinPayload = {
+              hook_event_name: hookEvent,
+              session_id: sessionId,
+              cwd: process.cwd(),
+              permission_mode: "default",
+              transcript_path: "",
+            };
+            const stdin = JSON.stringify(payload);
+
+            for (const cmd of commands) {
+              if (cmd.isAsync) {
+                execCommandAsync(cmd.command, stdin, env);
+                continue;
+              }
+              try {
+                execCommand(cmd.command, stdin, env, cmd.timeout);
+              } catch {
+                // Event hooks are non-blocking
+              }
+            }
+          },
+        },
+      }
+    : {}),
+};
+
+export default plugin;
+`;
+//# sourceMappingURL=shell-hooks-source.js.map

package/dist/agents/plugins/codemie-code-hooks/shell-hooks-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-hooks-source.js","sourceRoot":"","sources":["../../../../src/agents/plugins/codemie-code-hooks/shell-hooks-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2fxC,CAAC"}

package/dist/agents/plugins/codemie-code.plugin.d.ts

@@ -1,25 +1,69 @@
-import { AgentMetadata, AgentAdapter } from '../core/types.js';
+import type { AgentMetadata } from '../core/types.js';
+import { BaseAgentAdapter } from '../core/BaseAgentAdapter.js';
+import type { SessionAdapter } from '../core/session/BaseSessionAdapter.js';
+import type { BaseExtensionInstaller } from '../core/extension/BaseExtensionInstaller.js';
 /**
  * Built-in agent name constant - single source of truth
  */
 export declare const BUILTIN_AGENT_NAME = "codemie-code";
 /**
- * CodeMie-Code Plugin Metadata
+ * Environment variable contract between the umbrella CLI and whitelabel binary.
+ *
+ * The umbrella CLI orchestrates everything (proxy, auth, metrics, session sync)
+ * and spawns the whitelabel binary as a child process. The whitelabel knows
+ * nothing about SSO, cookies, or metrics — it just sees an OpenAI-compatible
+ * endpoint at localhost.
+ *
+ * Flow: BaseAgentAdapter.run() → setupProxy() → beforeRun hook → spawn(binary)
+ *
+ * | Env Var                  | Set By               | Consumed By          | Purpose                                        |
+ * |--------------------------|----------------------|----------------------|------------------------------------------------|
+ * | OPENCODE_CONFIG_CONTENT  | beforeRun hook       | Whitelabel config.ts | Full provider config JSON (proxy URL, models)  |
+ * | OPENCODE_CONFIG          | beforeRun (fallback) | Whitelabel config.ts | Temp file path when JSON exceeds env var limit |
+ * | OPENCODE_DISABLE_SHARE   | beforeRun hook       | Whitelabel           | Disables share functionality                   |
+ * | CODEMIE_SESSION_ID       | BaseAgentAdapter     | onSessionEnd hook    | Session ID for metrics correlation             |
+ * | CODEMIE_AGENT            | BaseAgentAdapter     | Lifecycle helpers    | Agent name ('codemie-code')                    |
+ * | CODEMIE_PROVIDER         | Config loader        | setupProxy()         | Provider name (e.g., 'ai-run-sso')             |
+ * | CODEMIE_BASE_URL         | setupProxy()         | beforeRun hook       | Proxy URL (http://localhost:{port})             |
+ * | CODEMIE_MODEL            | Config/CLI           | beforeRun hook       | Selected model ID                              |
+ * | CODEMIE_PROJECT          | SSO exportEnvVars    | Session metadata     | CodeMie project name                           |
  */
 export declare const CodeMieCodePluginMetadata: AgentMetadata;
 /**
- * CodeMie-Code Adapter
- * Custom implementation for built-in agent
+ * CodeMie Code Plugin
+ * Wraps the @codemieai/codemie-opencode binary as the built-in agent
  */
-export declare class CodeMieCodePlugin implements AgentAdapter {
-    name: string;
-    displayName: string;
-    description: string;
+export declare class CodeMieCodePlugin extends BaseAgentAdapter {
+    private sessionAdapter;
+    constructor();
+    /**
+     * Check if the agent is available.
+     * Returns true if the whitelabel binary is present, OR if only the built-in
+     * CodeMieCode handler is available (always the case when isBuiltIn: true).
+     * Warns at log level when the binary is absent so the condition is surfaced
+     * by doctor checks and debug sessions rather than silently swallowed.
+     */
+    isInstalled(): Promise<boolean>;
+    /**
+     * Install the whitelabel package globally.
+     */
     install(): Promise<void>;
+    /**
+     * Uninstall the whitelabel package and its platform-specific binary.
+     *
+     * npm hoists the platform-specific binary package (e.g.
+     * @codemieai/codemie-opencode-darwin-arm64) to the top-level global
+     * node_modules. `npm uninstall -g @codemieai/codemie-opencode` only removes
+     * the wrapper, leaving the binary as an orphan. We explicitly remove both.
+     */
     uninstall(): Promise<void>;
-    isInstalled(): Promise<boolean>;
-    run(args: string[], envOverrides?: Record<string, string>): Promise<void>;
-    getVersion(): Promise<string | null>;
-    getMetricsConfig(): import('../core/types.js').AgentMetricsConfig | undefined;
+    /**
+     * Return session adapter for analytics.
+     */
+    getSessionAdapter(): SessionAdapter;
+    /**
+     * No extension installer needed.
+     */
+    getExtensionInstaller(): BaseExtensionInstaller | undefined;
 }
 //# sourceMappingURL=codemie-code.plugin.d.ts.map

package/dist/agents/plugins/codemie-code.plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codemie-code.plugin.d.ts","sourceRoot":"","sources":["../../../src/agents/plugins/codemie-code.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAW/D;;GAEG;AACH,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,aA4GvC,CAAC;AAEF;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IACpD,IAAI,SAAsB;IAC1B,WAAW,SAAoB;IAC/B,WAAW,SAAsE;IAE3E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1B,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAI/B,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCzE,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAW1C,gBAAgB,IAAI,OAAO,kBAAkB,EAAE,kBAAkB,GAAG,SAAS;CAI9E"}
+{"version":3,"file":"codemie-code.plugin.d.ts","sourceRoot":"","sources":["../../../src/agents/plugins/codemie-code.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,kBAAkB,CAAC;AAMnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAU1F;;GAEG;AACH,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAsNjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,EAAE,aAqRvC,CAAC;AAEF;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;IACrD,OAAO,CAAC,cAAc,CAAiB;;IAOvC;;;;;;OAMG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAsBrC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;;;;OAOG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBhC;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;OAEG;IACH,qBAAqB,IAAI,sBAAsB,GAAG,SAAS;CAG5D"}