@ken-jo/agent-connector 0.1.0

package/dist/jetbrains-copilot-HWA3DMH7.js

@@ -0,0 +1,633 @@
+#!/usr/bin/env node
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  isHomeBinHookCommand
+} from "./chunk-MEH7GC7R.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/jetbrains-copilot/index.ts
+import { existsSync, rmSync } from "fs";
+import { dirname, join } from "path";
+var HOST = "jetbrains-copilot";
+var JETBRAINS_HOOKS_VERSION = 1;
+var EVENT_MAP = {
+  PreToolUse: "PreToolUse",
+  PostToolUse: "PostToolUse",
+  PreCompact: "PreCompact",
+  SessionStart: "SessionStart"
+};
+var JetBrainsCopilotAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "JetBrains Copilot";
+  paradigm = "json-stdio";
+  capabilities = {
+    // JetBrains Copilot's Preview hooks runtime delivers Pre/PostToolUse,
+    // PreCompact, and SessionStart (the four events its schema documents) —
+    // same surface as VS Code Copilot.
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    stop: false,
+    notification: false,
+    // Per the JetBrains spec this host is deny/ask-only: a PreToolUse hook
+    // CANNOT rewrite tool input, and PostToolUse cannot rewrite tool output.
+    canModifyArgs: false,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    // MCP is managed via the IDE Settings UI; the only transport that surfaces
+    // there is a local stdio server.
+    transports: ["stdio"],
+    // Content surfaces: JetBrains Copilot consumes the GitHub Copilot .github/
+    // files (it has no distinct authoring location), so it is an ALIAS of the
+    // vscode-copilot writer for prompt files and Agent Skills. It has no native
+    // subagent/chat-mode surface, so subagents stay unsupported (BaseAdapter
+    // returns the skip/warn default).
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: false
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const githubDir = join(projectDir, ".github");
+    const hooksDir = join(githubDir, "hooks");
+    const installed = existsSync(hooksDir) || existsSync(githubDir);
+    const configPath = hooksDir;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope: "project",
+      reason: installed ? `found JetBrains Copilot hooks tree at ${hooksDir}` : `no JetBrains Copilot hooks tree at ${hooksDir}`,
+      confidence: installed ? "medium" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  /** Hooks live under the workspace .github tree for both scopes. */
+  getConfigDir(ctx) {
+    return join(ctx.projectDir, ".github");
+  }
+  /**
+   * MCP server registration has NO writable file on JetBrains — the IDE owns it
+   * behind the Settings UI. We still return a stable path (the hooks file) so the
+   * base-adapter `doctor`/`backupSettings` helpers have a sensible target rather
+   * than a nonexistent/bogus MCP path. `installServer` never writes here.
+   */
+  getServerConfigPath(ctx) {
+    return this.getHookConfigPath(ctx);
+  }
+  /**
+   * Hook registration lives in the workspace-discovered .github/hooks tree, which
+   * JetBrains Copilot scans for *.json hook files. We write one file per connector
+   * so installs/uninstalls never clobber another connector's hooks. Anchored on
+   * projectDir for both scopes — .github/hooks is a workspace concept (there is no
+   * user-profile equivalent in the Copilot hooks schema).
+   */
+  getHookConfigPath(ctx) {
+    return join(ctx.projectDir, ".github", "hooks", `${ctx.connector.id}.json`);
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  /**
+   * JetBrains MCP registration is UI-only. We never write a file: a bogus file is
+   * ignored at best and corrupts real UI-managed state at worst. Emit a "warn"
+   * ChangeRecord that tells the user exactly where to add the server by hand.
+   */
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for jetbrains-copilot" : "connector declares no MCP server"
+        }
+      ];
+    }
+    return [
+      {
+        platform: this.id,
+        action: "warn",
+        detail: `JetBrains Copilot manages MCP servers via the IDE Settings UI \u2014 add "${connector.id}" manually under Settings > Tools > GitHub Copilot > MCP > Configure (no file is written here).`
+      }
+    ];
+  }
+  /**
+   * Nothing was written for the MCP server, so there is nothing to remove. Mirror
+   * the install-time guidance as a "warn" so an uninstall report is honest about
+   * the UI-managed entry the user may still want to remove by hand.
+   */
+  uninstallServer(ctx) {
+    const { connector } = ctx;
+    if (!connector.server || connector.platforms[HOST]?.server === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: "no MCP server was registered for jetbrains-copilot"
+        }
+      ];
+    }
+    return [
+      {
+        platform: this.id,
+        action: "warn",
+        detail: `JetBrains Copilot MCP servers are UI-managed \u2014 if "${connector.id}" was added manually, remove it under Settings > Tools > GitHub Copilot > MCP.`
+      }
+    ];
+  }
+  // ── Hook install / uninstall ─────────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.hooks === false) {
+      return [
+        { platform: this.id, action: "skip", detail: "hooks disabled for jetbrains-copilot" }
+      ];
+    }
+    if (connector.hookEvents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    }
+    const hooksPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hooksPath) ?? {};
+    const hooks = file.hooks ??= {};
+    const changes = [];
+    let mutated = false;
+    for (const event of connector.hookEvents) {
+      const jetbrainsEvent = EVENT_MAP[event];
+      if (!jetbrainsEvent) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: hooksPath,
+          detail: `${event} has no JetBrains Copilot hook equivalent \u2014 skipped`
+        });
+        continue;
+      }
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, event, connector.id);
+      const entry = { type: "command", command };
+      const bucket = hooks[jetbrainsEvent] ??= [];
+      const existingIdx = bucket.findIndex((e) => this.isOurCommand(e.command, ctx));
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: hooksPath,
+            detail: `hooks.${jetbrainsEvent} already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: hooksPath,
+          detail: `hooks.${jetbrainsEvent}`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: hooksPath,
+          detail: `hooks.${jetbrainsEvent}`
+        });
+      }
+      mutated = true;
+    }
+    if (mutated) {
+      file.version = JETBRAINS_HOOKS_VERSION;
+      this.writeJson(hooksPath, file, ctx.dryRun);
+    }
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const hooksPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hooksPath);
+    const hooks = file?.hooks;
+    if (!file || !hooks) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: hooksPath,
+          detail: "no hooks section present"
+        }
+      ];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const jetbrainsEvent of Object.keys(hooks)) {
+      const bucket = hooks[jetbrainsEvent];
+      if (!Array.isArray(bucket)) continue;
+      const before = bucket.length;
+      const next = bucket.filter((e) => !this.isOurCommand(e.command, ctx));
+      const removed = before - next.length;
+      if (removed > 0) {
+        if (next.length > 0) hooks[jetbrainsEvent] = next;
+        else delete hooks[jetbrainsEvent];
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: hooksPath,
+          detail: `hooks.${jetbrainsEvent} (${removed})`
+        });
+        mutated = true;
+      }
+    }
+    if (mutated) {
+      if (Object.keys(hooks).length === 0) {
+        if (!ctx.dryRun) rmSync(hooksPath, { force: true });
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: hooksPath,
+          detail: "removed empty connector hooks file"
+        });
+        changes.push(this.removeDirIfEmpty(dirname(hooksPath), ctx.dryRun));
+      } else {
+        this.writeJson(hooksPath, file, ctx.dryRun);
+      }
+    }
+    if (changes.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: hooksPath,
+        detail: "no matching hook entries"
+      });
+    }
+    return changes;
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surfaces: commands / skills ──────────────────────────────────
+  // CONTENT-ONLY: pure native-file writers under the workspace .github/ tree
+  // ({prompts,skills}). No runtime dispatch, no home-bin pointer, no telemetry
+  // wrap. Each method is idempotent (byte-identical → skip) via
+  // BaseAdapter.writeContentFile and reversible via removeContentFile. Honors
+  // platforms["jetbrains-copilot"] per-surface false to skip.
+  //
+  // ALIAS of vscode-copilot: JetBrains consumes the GitHub Copilot .github/
+  // files and has no distinct authoring location, so the rendered content +
+  // paths here are IDENTICAL to the vscode-copilot writer.
+  //
+  // SHARED .github TREE: vscode-copilot, copilot-cli, and jetbrains-copilot all
+  // write under the SAME project <projectDir>/.github tree. The rendered content
+  // is identical and idempotent across those connectors, and uninstall here only
+  // removes the files THIS connector declared — never another writer's files.
+  //
+  // SCOPE NOTE: .github is a workspace concept and this adapter is project-
+  // scoped (no user-profile .github authoring location exists in the Copilot
+  // prompt/skill discovery), so the content root is always the project .github
+  // tree — the same dir getConfigDir already anchors on.
+  /** Root of the content tree — the project .github tree (see getConfigDir). */
+  contentRootDir(ctx) {
+    return this.getConfigDir(ctx);
+  }
+  promptsDir(ctx) {
+    return join(this.contentRootDir(ctx), "prompts");
+  }
+  skillsDir(ctx) {
+    return join(this.contentRootDir(ctx), "skills");
+  }
+  /** Native command file path: <ghDir>/prompts/<name>.prompt.md. */
+  commandPath(ctx, name) {
+    return join(this.promptsDir(ctx), `${name}.prompt.md`);
+  }
+  /** Native skill dir: <ghDir>/skills/<name>. */
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  // ── Commands ──────────────────────────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for jetbrains-copilot" }];
+    }
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.writeContentFile(
+        this.commandPath(ctx, cmd.name),
+        this.renderCommand(cmd),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.removeContentFile(this.commandPath(ctx, cmd.name), ctx.dryRun)
+    );
+  }
+  /** Render a Copilot prompt file: md+frontmatter(description, tools, model, argument-hint). */
+  renderCommand(cmd) {
+    const frontmatter = {};
+    if (cmd.description !== void 0) frontmatter.description = cmd.description;
+    const allow = cmd.tools?.allow;
+    if (allow && allow.length > 0) frontmatter.tools = [...allow];
+    if (cmd.model !== void 0) frontmatter.model = cmd.model;
+    if (cmd.argumentHint !== void 0) frontmatter["argument-hint"] = cmd.argumentHint;
+    if (cmd.extra) Object.assign(frontmatter, cmd.extra);
+    return this.renderFrontmatterMd(frontmatter, cmd.prompt);
+  }
+  // ── Skills ────────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for jetbrains-copilot" }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /**
+   * Render a skill's SKILL.md — the uniform Agent Skills format: frontmatter
+   * (name, description + optional model, allowed-tools, disable-model-invocation)
+   * + body. Byte-identical to the other .github-sharing connectors so a shared
+   * skill folder never thrashes.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.model !== void 0) frontmatter.model = skill.model;
+    const allow = skill.tools?.allow;
+    if (allow && allow.length > 0) frontmatter["allowed-tools"] = allow.join(", ");
+    if (skill.disableModelInvocation !== void 0) {
+      frontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    }
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const hooksPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    const hasServer = ctx.connector.server != null && ctx.connector.platforms[HOST]?.server !== false;
+    const checks = [
+      {
+        // MCP cannot be verified from disk — JetBrains owns it behind the UI.
+        // BaseAdapter.doctor maps != OK to a hard FAIL, but an unverifiable
+        // UI-managed surface must NOT hard-fail doctor (that contradicts the
+        // install-time WARN). Return OK with a verify-in-UI detail instead.
+        name: `${this.name}: MCP server (UI-managed)`,
+        check: () => hasServer ? {
+          status: "OK",
+          detail: "MCP is UI-managed \u2014 verify in Settings > Tools > GitHub Copilot > MCP"
+        } : { status: "OK", detail: "connector declares no MCP server" }
+      },
+      {
+        name: `${this.name}: hook command registered`,
+        check: () => {
+          if (hookEvents.length === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const file = this.readJson(hooksPath);
+          if (!file) return { status: "FAIL", detail: `not found: ${hooksPath}` };
+          if (file.version !== JETBRAINS_HOOKS_VERSION) {
+            return {
+              status: "FAIL",
+              detail: `${hooksPath} missing required "version": ${JETBRAINS_HOOKS_VERSION} \u2014 Copilot rejects it`
+            };
+          }
+          const registered = Object.values(file.hooks ?? {}).some(
+            (entries) => (entries ?? []).some(
+              (e) => isHomeBinHookCommand(e.command, homeBin, connectorId)
+            )
+          );
+          return registered ? { status: "OK", detail: "hook command present" } : { status: "FAIL", detail: `no hook for ${connectorId} in ${hooksPath}` };
+        }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = this.commandPath(ctx, cmd.name);
+      checks.push({
+        name: `${this.name}: command ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(this.skillDir(ctx, skill.name), "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    return checks;
+  }
+  // ── Runtime: parse JetBrains Copilot stdin JSON → normalized event ────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = extractSessionId(input);
+    const projectDir = this.getProjectDir(input);
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const toolOutput = toolResponseToString(input.tool_response) ?? input.tool_output ?? input.error_message;
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolOutput !== void 0 ? { toolOutput } : {},
+          ...input.error_message ? { isError: true } : {}
+        };
+        return ev;
+      }
+      case "PreCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source ?? input.trigger)
+        };
+        return ev;
+      }
+      case "SessionEnd": {
+        const ev = {
+          ...base,
+          ...typeof input.reason === "string" ? { reason: input.reason } : {}
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "Notification": {
+        const ev = {
+          ...base,
+          message: typeof input.message === "string" ? input.message : ""
+        };
+        return ev;
+      }
+      default: {
+        const _never = event;
+        throw new Error(`unsupported jetbrains-copilot hook event: ${String(_never)}`);
+      }
+    }
+  }
+  /** Resolve the project dir from the wire payload, preferring the explicit cwd. */
+  getProjectDir(input) {
+    return input.cwd ?? input.workspace_roots?.[0] ?? void 0;
+  }
+  // ── Runtime: normalized response → JetBrains Copilot native hook reply ────
+  formatReply(event, response) {
+    const hookEventName = event;
+    const decision = response.decision ?? "allow";
+    if (decision === "deny") {
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "deny",
+          permissionDecisionReason: response.reason ?? "Blocked by hook"
+        }
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "ask",
+          permissionDecisionReason: response.reason ?? "Confirmation required by hook"
+        }
+      });
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({
+        hookSpecificOutput: { hookEventName, additionalContext: response.additionalContext }
+      });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function extractSessionId(input) {
+  if (typeof input.transcript_path === "string") {
+    const m = input.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+    if (m && m[1]) return m[1];
+  }
+  if (typeof input.session_id === "string" && input.session_id !== "") {
+    return input.session_id;
+  }
+  return "";
+}
+function toolResponseToString(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function normalizeSessionSource(source) {
+  switch (source) {
+    case "compact":
+      return "compact";
+    case "resume":
+      return "resume";
+    case "clear":
+      return "clear";
+    default:
+      return "startup";
+  }
+}
+var adapter = new JetBrainsCopilotAdapter();
+var jetbrains_copilot_default = adapter;
+export {
+  JetBrainsCopilotAdapter,
+  adapter,
+  jetbrains_copilot_default as default
+};
+//# sourceMappingURL=jetbrains-copilot-HWA3DMH7.js.map