pi-ghcp-headers 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# pi-ghcp-headers
+
+Pi extension that customizes GitHub Copilot `X-Initiator` behavior with first-message/follow-up percentages.
+
+## Install (local dev)
+
+```bash
+pi -e ./index.ts
+```
+
+## Install (package)
+
+```bash
+pi install npm:pi-ghcp-headers
+```
+
+## Config
+
+Config is loaded from:
+
+- Global: `~/.pi/agent/ghcp-headers.json`
+- Project: `.pi/ghcp-headers.json`
+
+Project config overrides global config.
+
+### Keys
+
+- `firstMessageAgentPercent` (default `0`)
+- `followupMessageAgentPercent` (default `100`)
+- `debugEnabled` (default `false`)
+- `debugLogPath` (default `/tmp/pi-ghcp-headers-debug.log`)
+
+Example:
+
+```json
+{
+  "firstMessageAgentPercent": 0,
+  "followupMessageAgentPercent": 100,
+  "debugEnabled": false,
+  "debugLogPath": "/tmp/pi-ghcp-headers-debug.log"
+}
+```
+
+## Commands
+
+- `/ghcp-headers-status`
+- `/ghcp-headers-set <key> <value> [global|project]`
+- `/ghcp-headers-reset [global|project]`
+- `/ghcp-headers-debug <on|off> [global|project]`
+
+## Notes
+
+- Applies only to models from provider `github-copilot`.
+- Extension overrides Copilot provider runtime behavior and injects request headers via provider stream options.

package/index.ts

@@ -0,0 +1,559 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  type Api,
+  createAssistantMessageEventStream,
+  getApiProvider,
+  getModels,
+  type Model,
+  type SimpleStreamOptions,
+  type Context,
+  type AssistantMessage,
+  type AssistantMessageEvent,
+  type AssistantMessageEventStream,
+} from "@mariozechner/pi-ai";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { Text, type Component, matchesKey } from "@mariozechner/pi-tui";
+
+type Scope = "global" | "project";
+
+type HeadersConfig = {
+  firstMessageAgentPercent: number;
+  followupMessageAgentPercent: number;
+  debugEnabled: boolean;
+  debugLogPath: string;
+};
+
+type PartialHeadersConfig = Partial<HeadersConfig>;
+
+type DecisionMode = "first" | "followup";
+
+type LastDecision = {
+  mode: DecisionMode;
+  initiator: "agent" | "user";
+  randomPercent: number;
+  thresholdPercent: number;
+  firstMessageAgentPercent: number;
+  followupMessageAgentPercent: number;
+  messageCount: number;
+  timestamp: number;
+};
+
+const DEFAULTS: HeadersConfig = {
+  firstMessageAgentPercent: 0,
+  followupMessageAgentPercent: 100,
+  debugEnabled: false,
+  debugLogPath: "/tmp/pi-ghcp-headers-debug.log",
+};
+
+const GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "ghcp-headers.json");
+const PROVIDER_ID = "github-copilot";
+
+let lastDecision: LastDecision | undefined;
+
+function clampPercent(value: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.min(100, value));
+}
+
+function parseBoolean(value: string): boolean | undefined {
+  const v = value.trim().toLowerCase();
+  if (["1", "true", "on", "yes", "y"].includes(v)) return true;
+  if (["0", "false", "off", "no", "n"].includes(v)) return false;
+  return undefined;
+}
+
+function parseScope(value?: string): Scope | undefined {
+  if (!value) return undefined;
+  const v = value.trim().toLowerCase();
+  if (v === "global" || v === "project") return v;
+  return undefined;
+}
+
+function parseJsonConfig(filePath: string): PartialHeadersConfig {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as PartialHeadersConfig;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function getProjectConfigPath(cwd: string): string {
+  return path.join(cwd, ".pi", "ghcp-headers.json");
+}
+
+function resolveConfig(cwd: string): HeadersConfig {
+  const globalCfg = parseJsonConfig(GLOBAL_CONFIG_PATH);
+  const projectCfg = parseJsonConfig(getProjectConfigPath(cwd));
+  const merged = { ...DEFAULTS, ...globalCfg, ...projectCfg };
+  return {
+    firstMessageAgentPercent: clampPercent(merged.firstMessageAgentPercent, DEFAULTS.firstMessageAgentPercent),
+    followupMessageAgentPercent: clampPercent(merged.followupMessageAgentPercent, DEFAULTS.followupMessageAgentPercent),
+    debugEnabled: Boolean(merged.debugEnabled),
+    debugLogPath: typeof merged.debugLogPath === "string" && merged.debugLogPath.trim().length > 0
+      ? merged.debugLogPath
+      : DEFAULTS.debugLogPath,
+  };
+}
+
+function writeConfig(filePath: string, patch: PartialHeadersConfig): void {
+  const current = parseJsonConfig(filePath);
+  const next = { ...current, ...patch };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(next, null, 2));
+}
+
+function resetConfig(filePath: string): void {
+  if (fs.existsSync(filePath)) fs.rmSync(filePath);
+}
+
+function log(config: HeadersConfig, msg: string): void {
+  if (!config.debugEnabled) return;
+  try {
+    fs.appendFileSync(config.debugLogPath, `${new Date().toISOString()} ${msg}\n`);
+  } catch {
+    // no-op
+  }
+}
+
+function getPriorMessages(messages: Context["messages"]): Context["messages"] {
+  if (messages.length === 0) return messages;
+  const copy = [...messages];
+  const last = copy[copy.length - 1];
+  if (last.role === "user") {
+    copy.pop();
+  }
+  return copy;
+}
+
+function getMessageRole(message: Context["messages"][number]): string {
+  return (message as { role: string }).role;
+}
+
+function hasAssistantOrToolHistory(messages: Context["messages"]): boolean {
+  return messages.some((m) => {
+    const role = getMessageRole(m);
+    return role === "assistant" ||
+      role === "toolResult" ||
+      // Compacted and branch-switched contexts can contain only summaries.
+      // Those are still continuations and should be treated as followups.
+      role === "compactionSummary" ||
+      role === "branchSummary";
+  });
+}
+
+function summarizeRoles(messages: Context["messages"]): string {
+  const counts = new Map<string, number>();
+  for (const m of messages) {
+    const role = getMessageRole(m);
+    counts.set(role, (counts.get(role) ?? 0) + 1);
+  }
+  const countSummary = [...counts.entries()]
+    .map(([role, count]) => `${role}:${count}`)
+    .join(",");
+  const tail = messages.slice(-8).map((m) => getMessageRole(m)).join(">");
+  return `count=[${countSummary}] tail=[${tail}]`;
+}
+
+function pickInitiator(agentPercent: number): { initiator: "agent" | "user"; randomPercent: number; thresholdPercent: number } {
+  const randomPercent = Math.random() * 100;
+  return {
+    initiator: randomPercent < agentPercent ? "agent" : "user",
+    randomPercent,
+    thresholdPercent: agentPercent,
+  };
+}
+
+function createErrorAssistantMessage(model: Model<Api>, message: string): AssistantMessage {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: "error",
+    errorMessage: message,
+    timestamp: Date.now(),
+  };
+}
+
+function createStreamWrapper(
+  cwdProvider: () => string,
+  resolveOriginalApi: (modelId: string) => Api,
+) {
+  return (model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream => {
+    const stream = createAssistantMessageEventStream();
+
+    (async () => {
+      try {
+        const originalApi = resolveOriginalApi(model.id);
+        const base = getApiProvider(originalApi);
+        if (!base) {
+          throw new Error(`No base API provider for ${originalApi}`);
+        }
+
+        const config = resolveConfig(cwdProvider());
+        const priorMessages = getPriorMessages(context.messages);
+        const isFollowup = hasAssistantOrToolHistory(priorMessages);
+        const threshold = isFollowup ? config.followupMessageAgentPercent : config.firstMessageAgentPercent;
+        const sampled = pickInitiator(threshold);
+        const mode: DecisionMode = isFollowup ? "followup" : "first";
+
+        lastDecision = {
+          mode,
+          initiator: sampled.initiator,
+          randomPercent: sampled.randomPercent,
+          thresholdPercent: sampled.thresholdPercent,
+          firstMessageAgentPercent: config.firstMessageAgentPercent,
+          followupMessageAgentPercent: config.followupMessageAgentPercent,
+          messageCount: context.messages.length,
+          timestamp: Date.now(),
+        };
+
+        log(
+          config,
+          `[HEADERS] mode=${mode} X-Initiator=${sampled.initiator} random=${sampled.randomPercent.toFixed(2)} threshold=${sampled.thresholdPercent.toFixed(2)} first=${config.firstMessageAgentPercent.toFixed(2)} followup=${config.followupMessageAgentPercent.toFixed(2)} priorMessages=${priorMessages.length} ${summarizeRoles(priorMessages)}`,
+        );
+
+        const inner = base.streamSimple(
+          {
+            ...(model as Model<Api>),
+            api: originalApi,
+          } as never,
+          context,
+          {
+            ...options,
+            headers: {
+              ...(options?.headers ?? {}),
+              "X-Initiator": sampled.initiator,
+            },
+          },
+        );
+
+        for await (const event of inner) {
+          stream.push(event as AssistantMessageEvent);
+          if (event.type === "done" || event.type === "error") {
+            stream.end();
+            return;
+          }
+        }
+
+        stream.end();
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        stream.push({
+          type: "error",
+          reason: "error",
+          error: createErrorAssistantMessage(model, `ghcp-headers failed: ${msg}`),
+        });
+        stream.end();
+      }
+    })();
+
+    return stream;
+  };
+}
+
+const OVERRIDE_API = "ghcp-headers-api" as Api;
+
+function getCopilotModelsWithApiOverride() {
+  const sourceModels = getModels(PROVIDER_ID);
+  const apiByModelId = new Map<string, Api>();
+
+  const overriddenModels = sourceModels.map((m) => {
+    apiByModelId.set(m.id, m.api);
+    return {
+      id: m.id,
+      name: m.name,
+      api: OVERRIDE_API,
+      reasoning: m.reasoning,
+      input: m.input,
+      cost: m.cost,
+      contextWindow: m.contextWindow,
+      maxTokens: m.maxTokens,
+      headers: m.headers,
+    };
+  });
+
+  return { overriddenModels, apiByModelId };
+}
+
+function statusText(cwd: string): string {
+  const cfg = resolveConfig(cwd);
+  const globalPath = GLOBAL_CONFIG_PATH;
+  const projectPath = getProjectConfigPath(cwd);
+  const globalState = fs.existsSync(globalPath) ? "found" : "not found";
+  const projectState = fs.existsSync(projectPath) ? "found" : "not found";
+
+  const parts = [
+    `config(global): ${globalPath} (${globalState})`,
+    `config(project): ${projectPath} (${projectState})`,
+    `firstMessageAgentPercent=${cfg.firstMessageAgentPercent}`,
+    `followupMessageAgentPercent=${cfg.followupMessageAgentPercent}`,
+    `debugEnabled=${cfg.debugEnabled}`,
+    `debugLogPath=${cfg.debugLogPath}`,
+  ];
+
+  if (lastDecision) {
+    parts.push(
+      `lastDecision: mode=${lastDecision.mode} initiator=${lastDecision.initiator} random=${lastDecision.randomPercent.toFixed(2)} threshold=${lastDecision.thresholdPercent.toFixed(2)} at=${new Date(lastDecision.timestamp).toISOString()}`,
+    );
+  }
+
+  return parts.join("\n");
+}
+
+function targetConfigPath(cwd: string, scope?: Scope): string {
+  return (scope ?? "global") === "project" ? getProjectConfigPath(cwd) : GLOBAL_CONFIG_PATH;
+}
+
+function registerCommands(pi: ExtensionAPI, cwdProvider: () => string) {
+  pi.registerCommand("ghcp-headers-status", {
+    description: "Show ghcp-headers config and latest decision",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const cwd = cwdProvider();
+      const cfg = resolveConfig(cwd);
+      const globalPath = GLOBAL_CONFIG_PATH;
+      const projectPath = getProjectConfigPath(cwd);
+      const globalExists = fs.existsSync(globalPath);
+      const projectExists = fs.existsSync(projectPath);
+
+      await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => {
+        const globalLineRaw = `config(global): ${globalPath} (${globalExists ? "found" : "not found"})`;
+        const projectLineRaw = `config(project): ${projectPath} (${projectExists ? "found" : "not found"})`;
+
+        const globalLine = globalExists ? globalLineRaw : theme.fg("muted", globalLineRaw);
+        const projectLine = projectExists ? projectLineRaw : theme.fg("muted", projectLineRaw);
+
+        const lines = [
+          theme.fg("toolTitle", theme.bold("ghcp-headers status")),
+          "",
+          globalLine,
+          projectLine,
+          `firstMessageAgentPercent=${cfg.firstMessageAgentPercent}`,
+          `followupMessageAgentPercent=${cfg.followupMessageAgentPercent}`,
+          `debugEnabled=${cfg.debugEnabled}`,
+          `debugLogPath=${cfg.debugLogPath}`,
+        ];
+
+        if (lastDecision) {
+          lines.push(
+            `lastDecision: mode=${lastDecision.mode} initiator=${lastDecision.initiator} random=${lastDecision.randomPercent.toFixed(2)} threshold=${lastDecision.thresholdPercent.toFixed(2)} at=${new Date(lastDecision.timestamp).toISOString()}`,
+          );
+        }
+
+        lines.push("", theme.fg("muted", "[Esc or Enter to close]"));
+
+        const text = new Text(lines.join("\n"), 1, 1);
+
+        const component: Component = {
+          render: (width: number) => text.render(width),
+          invalidate: () => text.invalidate(),
+          handleInput: (data: string) => {
+            if (matchesKey(data, "escape") || matchesKey(data, "return")) {
+              done();
+            }
+          },
+        };
+
+        return component;
+      });
+    },
+  });
+
+  pi.registerCommand("ghcp-headers-set", {
+    description: "Interactively edit config (or: /ghcp-headers-set <key> <value> [global|project])",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const applySetting = (key: keyof HeadersConfig, valueRaw: string, scope?: Scope): boolean => {
+        const patch: PartialHeadersConfig = {};
+
+        if (key === "firstMessageAgentPercent" || key === "followupMessageAgentPercent") {
+          const num = Number(valueRaw);
+          if (!Number.isFinite(num)) {
+            ctx.ui.notify("Value must be a number between 0 and 100", "error");
+            return false;
+          }
+          patch[key] = clampPercent(num, 0);
+        } else if (key === "debugEnabled") {
+          const bool = parseBoolean(valueRaw);
+          if (bool === undefined) {
+            ctx.ui.notify("debugEnabled must be on/off, true/false, 1/0", "error");
+            return false;
+          }
+          patch.debugEnabled = bool;
+        } else if (key === "debugLogPath") {
+          patch.debugLogPath = valueRaw;
+        } else {
+          ctx.ui.notify("Unknown key", "error");
+          return false;
+        }
+
+        const file = targetConfigPath(cwdProvider(), scope);
+        writeConfig(file, patch);
+        ctx.ui.notify(`Updated ${key} in ${file}`, "info");
+        return true;
+      };
+
+      const trimmed = args.trim();
+
+      // Backwards-compatible non-interactive mode
+      if (trimmed.length > 0) {
+        const [keyRaw, valueRaw, scopeRaw] = trimmed.split(/\s+/, 3);
+        if (!keyRaw || valueRaw === undefined) {
+          ctx.ui.notify("Usage: /ghcp-headers-set <key> <value> [global|project]", "warning");
+          return;
+        }
+
+        const key = keyRaw as keyof HeadersConfig;
+        const scope = parseScope(scopeRaw);
+        if (scopeRaw && !scope) {
+          ctx.ui.notify("Scope must be global or project", "error");
+          return;
+        }
+
+        applySetting(key, valueRaw, scope);
+        return;
+      }
+
+      // Interactive mode
+      const scopeChoice = await ctx.ui.select("Select config scope", [
+        `global (${GLOBAL_CONFIG_PATH})`,
+        `project (${getProjectConfigPath(cwdProvider())})`,
+      ]);
+      if (!scopeChoice) return;
+      const scope: Scope = scopeChoice.startsWith("project") ? "project" : "global";
+
+      while (true) {
+        const cfg = resolveConfig(cwdProvider());
+        const keyChoice = await ctx.ui.select("Select setting to change (Esc to finish)", [
+          `firstMessageAgentPercent (current: ${cfg.firstMessageAgentPercent})`,
+          `followupMessageAgentPercent (current: ${cfg.followupMessageAgentPercent})`,
+          `debugEnabled (current: ${cfg.debugEnabled})`,
+          `debugLogPath (current: ${cfg.debugLogPath})`,
+        ]);
+
+        // Escape/cancel exits interactive editor
+        if (!keyChoice) {
+          ctx.ui.notify("ghcp-headers-set: done", "info");
+          return;
+        }
+
+        const key = keyChoice.split(" ")[0] as keyof HeadersConfig;
+
+        if (key === "debugEnabled") {
+          const boolChoice = await ctx.ui.select("Set debugEnabled", ["on", "off"]);
+          if (!boolChoice) continue;
+          applySetting(key, boolChoice, scope);
+          continue;
+        }
+
+        const input = await ctx.ui.input(`New value for ${key}:`);
+        if (input === undefined || input.trim().length === 0) {
+          continue;
+        }
+
+        applySetting(key, input.trim(), scope);
+      }
+    },
+  });
+
+  pi.registerCommand("ghcp-headers-reset", {
+    description: "Reset config file: /ghcp-headers-reset [global|project]",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const scope = parseScope(args.trim() || "global");
+      if (args.trim() && !scope) {
+        ctx.ui.notify("Scope must be global or project", "error");
+        return;
+      }
+      const file = targetConfigPath(cwdProvider(), scope);
+      resetConfig(file);
+      ctx.ui.notify(`Reset ${file}`, "info");
+    },
+  });
+
+  pi.registerCommand("ghcp-headers-debug", {
+    description: "Toggle debug: /ghcp-headers-debug <on|off> [global|project]",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const [valueRaw, scopeRaw] = args.trim().split(/\s+/, 2);
+      const bool = parseBoolean(valueRaw || "");
+      if (bool === undefined) {
+        ctx.ui.notify("Usage: /ghcp-headers-debug <on|off> [global|project]", "warning");
+        return;
+      }
+      const scope = parseScope(scopeRaw);
+      if (scopeRaw && !scope) {
+        ctx.ui.notify("Scope must be global or project", "error");
+        return;
+      }
+      const file = targetConfigPath(cwdProvider(), scope);
+      writeConfig(file, { debugEnabled: bool });
+      ctx.ui.notify(`debugEnabled=${bool} in ${file}`, "info");
+    },
+  });
+}
+
+export default function ghcpHeadersExtension(pi: ExtensionAPI) {
+  let currentCwd = process.cwd();
+  let providerRegistered = false;
+  const cwdProvider = () => currentCwd;
+
+  const tryRegisterProvider = () => {
+    const { overriddenModels, apiByModelId } = getCopilotModelsWithApiOverride();
+    if (overriddenModels.length === 0) {
+      const cfg = resolveConfig(cwdProvider());
+      log(cfg, "[INIT] github-copilot models unavailable; provider not registered yet");
+      return;
+    }
+
+    const resolveOriginalApi = (modelId: string): Api =>
+      apiByModelId.get(modelId) ?? "openai-completions";
+
+    pi.registerProvider(PROVIDER_ID, {
+      baseUrl: getModels(PROVIDER_ID)[0]?.baseUrl ?? "https://api.individual.githubcopilot.com",
+      apiKey: "GITHUB_COPILOT_TOKEN",
+      api: OVERRIDE_API,
+      streamSimple: createStreamWrapper(cwdProvider, resolveOriginalApi),
+      models: overriddenModels,
+    });
+
+    providerRegistered = true;
+    const cfg = resolveConfig(cwdProvider());
+    log(cfg, `[INIT] provider registered with ${overriddenModels.length} copilot model(s), api=${OVERRIDE_API}`);
+  };
+
+  registerCommands(pi, cwdProvider);
+  tryRegisterProvider();
+
+  pi.on("session_start", (_event: unknown, ctx: ExtensionContext) => {
+    currentCwd = ctx.cwd;
+    const cfg = resolveConfig(cwdProvider());
+    log(cfg, `[SESSION_START] cwd=${currentCwd}`);
+    if (!providerRegistered) {
+      tryRegisterProvider();
+    }
+  });
+
+  pi.on("session_switch", (_event: unknown, ctx: ExtensionContext) => {
+    currentCwd = ctx.cwd;
+    const cfg = resolveConfig(cwdProvider());
+    log(cfg, `[SESSION_SWITCH] cwd=${currentCwd}`);
+    if (!providerRegistered) {
+      tryRegisterProvider();
+    }
+  });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pi-ghcp-headers",
+  "version": "0.1.0",
+  "description": "Pi extension to customize GitHub Copilot X-Initiator header behavior",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "github-copilot",
+    "x-initiator"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "files": [
+    "index.ts",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-ai": "^0.55.3",
+    "@mariozechner/pi-coding-agent": "^0.55.3",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["index.ts"]
+}