oh-my-githubcopilot 1.5.7 → 1.8.0-alpha.f50f59a

package/bin/omp.mjs

@@ -73,22 +73,22 @@ var init_renderer = __esm({
 
 // src/hud/statusline.mts
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
-function getStatuslinePaths(home = process.env["HOME"] || homedir()) {
-  const ompDir = join(home, ".omp");
-  const hudDir = join(ompDir, "hud");
+function getStatuslinePaths(home = process.env["HOME"] || homedir2()) {
+  const ompDir = join2(home, ".omp");
+  const hudDir = join2(ompDir, "hud");
   return {
-    legacyLinePath: join(ompDir, "hud.line"),
+    legacyLinePath: join2(ompDir, "hud.line"),
     hudDir,
-    statusJsonPath: join(hudDir, "status.json"),
-    displayPath: join(hudDir, "display.txt"),
-    tmuxSegmentPath: join(hudDir, "tmux-segment.sh")
+    statusJsonPath: join2(hudDir, "status.json"),
+    displayPath: join2(hudDir, "display.txt"),
+    tmuxSegmentPath: join2(hudDir, "tmux-segment.sh")
   };
 }
 function ensureParent(filePath) {
-  mkdirSync(dirname(filePath), { recursive: true });
+  mkdirSync(dirname2(filePath), { recursive: true });
 }
 function writeAtomic(filePath, content, mode) {
   ensureParent(filePath);
@@ -228,8 +228,8 @@ __export(watch_exports, {
   runHudWatch: () => runHudWatch
 });
 import { readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 function readSnapshot() {
   try {
     const raw = readFileSync2(STATE_PATH, "utf-8");
@@ -279,13 +279,376 @@ var init_watch = __esm({
     init_statusline();
     init_renderer();
     DEFAULT_INTERVAL_MS = 2e3;
-    STATE_PATH = join2(homedir2(), ".omp", "state", "session.json");
+    STATE_PATH = join3(homedir3(), ".omp", "state", "session.json");
+  }
+});
+
+// src/hooks/keyword-detector.mts
+var keyword_detector_exports = {};
+__export(keyword_detector_exports, {
+  processHook: () => processHook
+});
+function detectKeyword(prompt) {
+  const trimmed = prompt.trimStart();
+  for (const [keyword, skillId] of KEYWORD_ENTRIES) {
+    if (trimmed.startsWith(keyword)) {
+      return {
+        keyword,
+        skillId,
+        position: 0
+      };
+    }
+  }
+  const slashPattern = /^\/((?:omp:)?[a-zA-Z][a-zA-Z0-9-]*)\b/;
+  const slashMatch = trimmed.match(slashPattern);
+  if (slashMatch) {
+    const cmd = slashMatch[1].toLowerCase();
+    const skillId = KEYWORD_MAP[`/${cmd}`] ?? KEYWORD_MAP[`${cmd}:`];
+    if (skillId) {
+      return {
+        keyword: slashMatch[0],
+        skillId,
+        position: 0
+      };
+    }
+  }
+  const longNamespacePattern = /^\/?oh-my-githubcopilot:([a-zA-Z][a-zA-Z0-9-]*)\b/i;
+  const longNamespaceMatch = trimmed.match(longNamespacePattern);
+  if (longNamespaceMatch) {
+    const cmd = longNamespaceMatch[1].toLowerCase();
+    const skillId = KEYWORD_MAP[`/omp:${cmd}`] ?? KEYWORD_MAP[`/${cmd}`] ?? KEYWORD_MAP[`${cmd}:`];
+    if (skillId) {
+      return {
+        keyword: longNamespaceMatch[0],
+        skillId,
+        position: 0
+      };
+    }
+  }
+  return null;
+}
+function getCanonicalCommand(skillId) {
+  return CANONICAL_COMMAND_MAP[skillId] ?? `/omp:${skillId}`;
+}
+function processHook(input) {
+  const start = Date.now();
+  const log = [];
+  try {
+    if (input.hook_type !== "UserPromptSubmitted") {
+      return {
+        status: "skip",
+        latencyMs: Date.now() - start,
+        mutations: [],
+        log: ["Not a UserPromptSubmitted hook"]
+      };
+    }
+    const match = detectKeyword(input.prompt);
+    if (!match) {
+      return {
+        status: "ok",
+        latencyMs: Date.now() - start,
+        mutations: [],
+        log: []
+      };
+    }
+    const taskPart = input.prompt.slice(match.position + match.keyword.length).trim();
+    const rewritten = `${getCanonicalCommand(match.skillId)}${taskPart ? ` ${taskPart}` : ""}`;
+    log.push(`Keyword detected: "${match.keyword}" \u2192 skill: ${match.skillId}`);
+    log.push(`Rewritten: "${rewritten}"`);
+    return {
+      status: "ok",
+      latencyMs: Date.now() - start,
+      modifiedPrompt: rewritten,
+      mutations: [
+        { type: "set_mode", mode: match.skillId },
+        { type: "log", level: "info", message: `Skill activated: ${match.skillId}` }
+      ],
+      log
+    };
+  } catch (err) {
+    return {
+      status: "error",
+      latencyMs: Date.now() - start,
+      mutations: [],
+      log: [`Error: ${err}`]
+    };
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return chunks.join("");
+}
+var KEYWORD_MAP, KEYWORD_ENTRIES, CANONICAL_COMMAND_MAP;
+var init_keyword_detector = __esm({
+  async "src/hooks/keyword-detector.mts"() {
+    "use strict";
+    KEYWORD_MAP = {
+      "autopilot:": "autopilot",
+      "/autopilot": "autopilot",
+      "/omp:autopilot": "autopilot",
+      "ralph:": "ralph",
+      "/ralph": "ralph",
+      "/omp:ralph": "ralph",
+      "ulw:": "ultrawork",
+      "ultrawork:": "ultrawork",
+      "/ulw": "ultrawork",
+      "/ultrawork": "ultrawork",
+      "/omp:ulw": "ultrawork",
+      "/omp:ultrawork": "ultrawork",
+      "team:": "team",
+      "/team": "team",
+      "/omp:team": "team",
+      "eco:": "ecomode",
+      "ecomode:": "ecomode",
+      "/eco": "ecomode",
+      "/ecomode": "ecomode",
+      "/omp:eco": "ecomode",
+      "/omp:ecomode": "ecomode",
+      "swarm:": "swarm",
+      "/swarm": "swarm",
+      "/omp:swarm": "swarm",
+      "pipeline:": "pipeline",
+      "/pipeline": "pipeline",
+      "/omp:pipeline": "pipeline",
+      "deep interview:": "deep-interview",
+      "/deep-interview": "deep-interview",
+      "/omp:deep-interview": "deep-interview",
+      "plan:": "omp-plan",
+      "/plan": "omp-plan",
+      "/omp-plan": "omp-plan",
+      "/omp:plan": "omp-plan",
+      "setup:": "omp-setup",
+      "/setup": "omp-setup",
+      "/omp-setup": "omp-setup",
+      "/omp:setup": "omp-setup",
+      "mcp:": "mcp-setup",
+      "mcp-setup:": "mcp-setup",
+      "/mcp": "mcp-setup",
+      "/mcp-setup": "mcp-setup",
+      "/omp:mcp-setup": "mcp-setup",
+      "/hud": "hud",
+      "hud:": "hud",
+      "/omp:hud": "hud",
+      "/wiki": "wiki",
+      "wiki:": "wiki",
+      "/omp:wiki": "wiki",
+      "/learner": "learner",
+      "learner:": "learner",
+      "/omp:learner": "learner",
+      "/note": "note",
+      "note:": "note",
+      "/omp:note": "note",
+      "/trace": "trace",
+      "trace:": "trace",
+      "/omp:trace": "trace",
+      "/release": "release",
+      "release:": "release",
+      "/omp:release": "release",
+      "/configure-notifications": "configure-notifications",
+      "configure-notifications:": "configure-notifications",
+      "/omp:configure-notifications": "configure-notifications",
+      "/psm": "psm",
+      "psm:": "psm",
+      "/omp:psm": "psm",
+      "/swe-bench": "swe-bench",
+      "swe-bench:": "swe-bench",
+      "/omp:swe-bench": "swe-bench",
+      "graphify:": "graphify",
+      "graph build": "graphify",
+      "build graph": "graphify",
+      "graphwiki:": "graphwiki",
+      "graph:": "graph-provider",
+      "spending:": "spending",
+      "/graphify": "graphify",
+      "/omp:graphify": "graphify",
+      "/graphwiki": "graphwiki",
+      "/omp:graphwiki": "graphwiki",
+      "/graph-provider": "graph-provider",
+      "/omp:graph-provider": "graph-provider",
+      "/spending": "spending",
+      "/omp:spending": "spending",
+      "--consensus": "omp-plan",
+      "/omp:omp-doctor": "omp-doctor",
+      "/omp:ralplan": "ralplan",
+      "/omp:research": "research",
+      "doctor:": "doctor",
+      "/doctor": "doctor",
+      "/omp:doctor": "doctor",
+      "interview:": "interview",
+      "/interview": "interview",
+      "/omp:interview": "interview",
+      "notifications:": "notifications",
+      "/notifications": "notifications",
+      "/omp:notifications": "notifications",
+      "session:": "session",
+      "/session": "session",
+      "/omp:session": "session"
+    };
+    KEYWORD_ENTRIES = Object.entries(KEYWORD_MAP).sort(([a], [b]) => b.length - a.length);
+    CANONICAL_COMMAND_MAP = {
+      "omp-plan": "/omp:plan",
+      "omp-setup": "/setup",
+      "mcp-setup": "/mcp"
+    };
+    if (process.argv[1]?.endsWith("keyword-detector.mjs") || process.argv[1]?.endsWith("keyword-detector.mts")) {
+      const input = JSON.parse(await readStdin());
+      const output = processHook(input);
+      console.log(JSON.stringify(output));
+    }
   }
 });
 
 // src/index.mts
 import { parseArgs } from "util";
 import { createRequire } from "module";
+
+// src/cli/update.mts
+import { spawnSync } from "child_process";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createInterface } from "node:readline/promises";
+var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
+var PROMPTABLE_SUBCOMMANDS = /* @__PURE__ */ new Set(["hud", "psm", "bench"]);
+var DISABLED_AUTO_UPDATE_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var ENABLED_DISABLE_FLAG_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function parseSemver(version) {
+  const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? null
+  };
+}
+function isNewerVersion(current, latest) {
+  const currentVersion = parseSemver(current);
+  const latestVersion = parseSemver(latest);
+  if (!currentVersion || !latestVersion) return false;
+  if (latestVersion.major !== currentVersion.major) return latestVersion.major > currentVersion.major;
+  if (latestVersion.minor !== currentVersion.minor) return latestVersion.minor > currentVersion.minor;
+  if (latestVersion.patch !== currentVersion.patch) return latestVersion.patch > currentVersion.patch;
+  if (currentVersion.prerelease && !latestVersion.prerelease) return true;
+  return false;
+}
+function shouldCheckForUpdates(nowMs, state, intervalMs = CHECK_INTERVAL_MS) {
+  if (!state?.last_checked_at) return true;
+  const lastCheckedAt = Date.parse(state.last_checked_at);
+  if (!Number.isFinite(lastCheckedAt)) return true;
+  return nowMs - lastCheckedAt >= intervalMs;
+}
+function isAutoUpdateDisabled(env = process.env) {
+  const autoUpdate = env["OMP_AUTO_UPDATE"]?.trim().toLowerCase();
+  if (autoUpdate && DISABLED_AUTO_UPDATE_VALUES.has(autoUpdate)) return true;
+  const disableCheck = env["OMP_DISABLE_UPDATE_CHECK"]?.trim().toLowerCase();
+  if (disableCheck && ENABLED_DISABLE_FLAG_VALUES.has(disableCheck)) return true;
+  return false;
+}
+function shouldSkipUpdatePrompt(subcommand2, flags2 = {}) {
+  if (flags2.help || flags2.version) return true;
+  return !PROMPTABLE_SUBCOMMANDS.has(subcommand2);
+}
+function updateStatePath(homeDir) {
+  return join(homeDir, ".omp", "state", "update-check.json");
+}
+async function readCachedUpdateState(statePath) {
+  try {
+    const raw = await readFile(statePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCachedUpdateState(statePath, state) {
+  await mkdir(dirname(statePath), { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+async function fetchLatestVersionFromNpm(packageName, timeoutMs = 3500) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+    const response = await fetch(url, { signal: controller.signal });
+    if (!response.ok) return null;
+    const payload = await response.json();
+    return typeof payload.version === "string" ? payload.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function runNpmGlobalUpdate(packageName, cwd) {
+  const result = spawnSync("npm", ["install", "-g", `${packageName}@latest`], {
+    encoding: "utf-8",
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: 12e4,
+    windowsHide: true,
+    cwd
+  });
+  if (result.error) return { ok: false, stderr: result.error.message };
+  if (result.status !== 0) {
+    return { ok: false, stderr: (result.stderr || "").trim() || `npm exited ${result.status}` };
+  }
+  return { ok: true, stderr: "" };
+}
+async function askYesNo(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const readline = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await readline.question(question)).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    readline.close();
+  }
+}
+var defaultDependencies = {
+  nowMs: () => Date.now(),
+  readUpdateState: readCachedUpdateState,
+  writeUpdateState: writeCachedUpdateState,
+  fetchLatestVersion: fetchLatestVersionFromNpm,
+  askYesNo,
+  runGlobalUpdate: runNpmGlobalUpdate
+};
+async function maybeCheckAndPromptUpdate(context, dependencies = {}) {
+  const updateDependencies = {
+    ...defaultDependencies,
+    ...dependencies
+  };
+  try {
+    if (isAutoUpdateDisabled()) return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+    if (shouldSkipUpdatePrompt(context.subcommand, context.flags)) return;
+    const statePath = updateStatePath(process.env["HOME"] || homedir());
+    const now = updateDependencies.nowMs();
+    const state = await updateDependencies.readUpdateState(statePath);
+    if (!shouldCheckForUpdates(now, state)) return;
+    const latestVersion = await updateDependencies.fetchLatestVersion(context.packageName);
+    await updateDependencies.writeUpdateState(statePath, {
+      last_checked_at: new Date(now).toISOString(),
+      last_seen_latest: latestVersion || state?.last_seen_latest
+    });
+    if (!latestVersion || !isNewerVersion(context.currentVersion, latestVersion)) return;
+    const approved = await updateDependencies.askYesNo(
+      `[omp] Update available: v${context.currentVersion} \u2192 v${latestVersion}. Update now? [Y/n] `
+    );
+    if (!approved) return;
+    console.log(`[omp] Running: npm install -g ${context.packageName}@latest`);
+    const result = updateDependencies.runGlobalUpdate(context.packageName, context.cwd);
+    if (result.ok) {
+      console.log(`[omp] Updated to v${latestVersion}. Restart this shell to load the new CLI.`);
+    } else {
+      console.log(`[omp] Update failed. Run manually: npm install -g ${context.packageName}@latest`);
+    }
+  } catch {
+  }
+}
+
+// src/index.mts
 var _require = createRequire(import.meta.url);
 var { version: PKG_VERSION, name: PKG_NAME } = _require("../package.json");
 var { positionals, values: flags } = parseArgs({
@@ -298,8 +661,23 @@ var { positionals, values: flags } = parseArgs({
   allowPositionals: true
 });
 var subcommand = positionals[0] || "hud";
+var resolvedSubcommand = flags.version && !positionals[0] ? "version" : subcommand;
 async function main() {
-  switch (subcommand) {
+  if (flags.help) {
+    printUsage();
+    return;
+  }
+  await maybeCheckAndPromptUpdate({
+    cwd: process.cwd(),
+    packageName: PKG_NAME,
+    currentVersion: PKG_VERSION,
+    subcommand: resolvedSubcommand,
+    flags: {
+      help: flags.help,
+      version: flags.version
+    }
+  });
+  switch (resolvedSubcommand) {
     case "hud":
       if (flags.watch) {
         const { runHudWatch: runHudWatch2 } = await Promise.resolve().then(() => (init_watch(), watch_exports));
@@ -317,18 +695,25 @@ async function main() {
     case "bench":
       await runBench(positionals.slice(1));
       break;
+    case "hook":
+      await runHook(positionals.slice(1));
+      break;
     default:
-      console.error(`Unknown subcommand: ${subcommand}`);
-      console.error("Usage: omp [hud|version|psm|bench]");
+      console.error(`Unknown subcommand: ${resolvedSubcommand}`);
+      printUsage(true);
       process.exit(1);
   }
 }
+function printUsage(stderr = false) {
+  const output = stderr ? console.error : console.log;
+  output("Usage: omp [hud|version|psm|bench|hook] [--watch]");
+}
 async function printHud() {
   try {
     const { readFileSync: readFileSync3 } = await import("fs");
-    const { join: join3 } = await import("path");
-    const { homedir: homedir3 } = await import("os");
-    const hudPath = join3(homedir3(), ".omp", "hud.line");
+    const { join: join4 } = await import("path");
+    const { homedir: homedir4 } = await import("os");
+    const hudPath = join4(homedir4(), ".omp", "hud.line");
     const line = readFileSync3(hudPath, "utf-8").trim();
     console.log(line);
   } catch {
@@ -342,6 +727,25 @@ async function runPsm(_args) {
   console.log("  /omp:psm switch <name>  Switch to session");
   console.log("  /omp:psm destroy <name> Destroy session");
 }
+async function runHook(args) {
+  const hookId = args[0];
+  if (hookId !== "keyword-detector") {
+    console.error("Usage: omp hook keyword-detector");
+    process.exit(1);
+  }
+  const { processHook: processHook2 } = await init_keyword_detector().then(() => keyword_detector_exports);
+  const inputText = await readStdin2();
+  const input = JSON.parse(inputText || "{}");
+  const output = processHook2(input);
+  console.log(JSON.stringify(output));
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
+}
 async function runBench(_args) {
   console.log("SWE-bench requires Node.js subprocess with Python evaluation harness.");
   console.log("Usage: /omp:swe-bench --suite lite --compare baseline");