omegon 0.6.0

package/extensions/tool-profile/profiles.ts

@@ -0,0 +1,290 @@
+/**
+ * Profile definitions and project detection logic.
+ *
+ * A profile is a named group of tools that should be active together.
+ * Detection functions scan the cwd for project signals to determine
+ * which profiles apply.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ── Profile Definitions ─────────────────────────────────────────
+
+export interface Profile {
+  /** Profile identifier */
+  id: string;
+  /** Human-readable label */
+  label: string;
+  /** Description shown in /profile list */
+  description: string;
+  /** Tool name patterns to include. Exact match or glob-like prefix (e.g. "mcp_scribe_*") */
+  tools: string[];
+  /** Detection function: returns true if this profile should be auto-activated */
+  detect: (cwd: string) => boolean;
+  /** If true, always included regardless of detection */
+  alwaysOn?: boolean;
+}
+
+/** Check if a command exists on PATH */
+function hasCmd(name: string): boolean {
+  try {
+    execSync(`command -v ${name}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function fileExists(cwd: string, ...paths: string[]): boolean {
+  return paths.some((p) => existsSync(join(cwd, p)));
+}
+
+/** Check if any file with the given extension exists in common content directories (shallow). */
+function dirHasExt(cwd: string, ext: string): boolean {
+  // Only check top-level and common content dirs — never walk node_modules/.git/etc.
+  const SCAN_DIRS = [".", "docs", "assets", "images", "diagrams", "design", "src", "lib"];
+  for (const dir of SCAN_DIRS) {
+    try {
+      const fullDir = join(cwd, dir);
+      const entries = readdirSync(fullDir);
+      if (entries.some((e) => e.endsWith(ext))) return true;
+    } catch {
+      // Directory doesn't exist, skip
+    }
+  }
+  return false;
+}
+
+function readJsonField(cwd: string, file: string, field: string): unknown {
+  try {
+    const raw = readFileSync(join(cwd, file), "utf8");
+    const json = JSON.parse(raw);
+    return json[field];
+  } catch {
+    return undefined;
+  }
+}
+
+export const PROFILES: Profile[] = [
+  {
+    id: "core",
+    label: "Core",
+    description: "Essential tools: built-in file/shell ops, memory, chronos, auth, model control",
+    alwaysOn: true,
+    tools: [
+      // pi built-in tools (lowercase — these are pi's native tools, not Claude Code's
+      // PascalCase variants). Must be included or setActiveTools() deactivates them.
+      "read", "write", "edit", "bash",
+      // Memory
+      "memory_query", "memory_recall", "memory_episodes", "memory_focus",
+      "memory_release", "memory_store", "memory_supersede", "memory_search_archive",
+      "memory_connect", "memory_archive", "memory_compact",
+      // Utilities
+      "chronos", "whoami",
+      // Model control
+      "set_model_tier", "set_thinking_level", "switch_to_offline_driver",
+      // Tool management
+      "manage_tools",
+    ],
+    detect: () => true,
+  },
+  {
+    id: "coding",
+    label: "Coding",
+    description: "Cleave decomposition, OpenSpec, design tree",
+    tools: [
+      "cleave_assess", "cleave_run",
+      "openspec_manage",
+      "design_tree", "design_tree_update",
+    ],
+    detect: (cwd) => fileExists(cwd, ".git"),
+  },
+  {
+    id: "visual",
+    label: "Visual",
+    description: "Image generation, D2 diagrams, Excalidraw rendering",
+    tools: [
+      "generate_image_local", "render_diagram", "render_excalidraw",
+    ],
+    detect: (cwd) =>
+      fileExists(cwd, "images") ||
+      dirHasExt(cwd, ".excalidraw") ||
+      dirHasExt(cwd, ".d2"),
+  },
+  {
+    id: "local-ai",
+    label: "Local AI",
+    description: "Ollama local inference (ask_local_model, manage_ollama)",
+    tools: [
+      "ask_local_model", "list_local_models", "manage_ollama",
+    ],
+    detect: () => hasCmd("ollama"),
+  },
+  {
+    id: "web",
+    label: "Web & View",
+    description: "Web search and file viewing",
+    alwaysOn: true,
+    tools: ["web_search", "view"],
+    detect: () => true,
+  },
+  {
+    id: "scribe",
+    label: "Scribe",
+    description: "Partnership tracking via MCP bridge (mcp_scribe_*)",
+    tools: ["mcp_scribe_*"],
+    detect: (cwd) => {
+      // Detect if scribe MCP is configured — check for .pi/mcp.json or similar
+      return fileExists(cwd, ".pi/mcp.json") ||
+        existsSync(join(homedir(), ".pi", "mcp.json"));
+    },
+  },
+  {
+    id: "pi-dev",
+    label: "Pi Development",
+    description: "All tools enabled — for working on Omegon itself",
+    tools: ["*"],
+    detect: (cwd) => {
+      const piExts = readJsonField(cwd, "package.json", "pi") as { extensions?: string[] } | undefined;
+      return !!piExts?.extensions;
+    },
+  },
+];
+
+// ── Profile Config (persisted) ──────────────────────────────────
+
+export interface ProfileConfig {
+  /** Profiles to force-include regardless of detection */
+  include?: string[];
+  /** Profiles to force-exclude regardless of detection */
+  exclude?: string[];
+  /** Individual tool overrides */
+  tools?: {
+    enable?: string[];
+    disable?: string[];
+  };
+}
+
+export function loadProfileConfig(cwd: string): ProfileConfig {
+  const configPath = join(cwd, ".pi", "profile.json");
+  try {
+    return JSON.parse(readFileSync(configPath, "utf8")) as ProfileConfig;
+  } catch {
+    return {};
+  }
+}
+
+// ── Detection & Merge ───────────────────────────────────────────
+
+/** Detect which profiles should be active for the given cwd */
+export function detectProfiles(cwd: string): string[] {
+  return PROFILES
+    .filter((p) => p.alwaysOn || p.detect(cwd))
+    .map((p) => p.id);
+}
+
+/** Match a tool name against a pattern (exact or wildcard suffix) */
+export function matchTool(toolName: string, pattern: string): boolean {
+  if (pattern === "*") return true;
+  if (pattern.endsWith("*")) {
+    return toolName.startsWith(pattern.slice(0, -1));
+  }
+  return toolName === pattern;
+}
+
+/** Given detected profiles + config overrides, compute the active tool set */
+export function resolveActiveTools(
+  allToolNames: string[],
+  detectedProfileIds: string[],
+  config: ProfileConfig,
+): string[] {
+  // Apply include/exclude overrides to detected profiles
+  let activeProfileIds = new Set(detectedProfileIds);
+
+  for (const id of config.include ?? []) {
+    activeProfileIds.add(id);
+  }
+  for (const id of config.exclude ?? []) {
+    activeProfileIds.delete(id);
+  }
+
+  // Collect tool patterns from active profiles
+  const activeProfiles = PROFILES.filter((p) => activeProfileIds.has(p.id));
+  const patterns = activeProfiles.flatMap((p) => p.tools);
+
+  // Check for wildcard — if any profile has "*", enable all
+  if (patterns.includes("*")) {
+    let tools = new Set(allToolNames);
+    for (const name of config.tools?.disable ?? []) {
+      tools.delete(name);
+    }
+    return [...tools];
+  }
+
+  // Match tools against patterns
+  let enabledTools = new Set<string>();
+  for (const toolName of allToolNames) {
+    if (patterns.some((p) => matchTool(toolName, p))) {
+      enabledTools.add(toolName);
+    }
+  }
+
+  // Apply individual tool overrides
+  for (const name of config.tools?.enable ?? []) {
+    if (allToolNames.includes(name)) {
+      enabledTools.add(name);
+    }
+  }
+  for (const name of config.tools?.disable ?? []) {
+    enabledTools.delete(name);
+  }
+
+  return [...enabledTools];
+}
+
+/** Format a summary of active/inactive profiles for display */
+export function formatProfileSummary(
+  detectedIds: string[],
+  config: ProfileConfig,
+  allToolNames: string[],
+): string {
+  const activeTools = resolveActiveTools(allToolNames, detectedIds, config);
+  const lines: string[] = [];
+
+  lines.push("## Tool Profiles\n");
+
+  for (const profile of PROFILES) {
+    const detected = detectedIds.includes(profile.id);
+    const included = config.include?.includes(profile.id);
+    const excluded = config.exclude?.includes(profile.id);
+
+    let status: string;
+    if (excluded) {
+      status = "⊘ excluded";
+    } else if (detected || included) {
+      status = included && !detected ? "✓ forced" : "✓ active";
+    } else {
+      status = "○ inactive";
+    }
+
+    const toolCount = profile.tools.includes("*")
+      ? "all"
+      : `${profile.tools.length} tools`;
+
+    lines.push(`- **${profile.label}** (${profile.id}): ${status} — ${toolCount}`);
+  }
+
+  lines.push("");
+  lines.push(`**Active:** ${activeTools.length}/${allToolNames.length} tools`);
+
+  if (config.tools?.enable?.length || config.tools?.disable?.length) {
+    lines.push("\n**Overrides:**");
+    for (const t of config.tools?.enable ?? []) lines.push(`  + ${t}`);
+    for (const t of config.tools?.disable ?? []) lines.push(`  - ${t}`);
+  }
+
+  return lines.join("\n");
+}

package/extensions/types.d.ts

@@ -0,0 +1,9 @@
+import "@cwilson613/pi-coding-agent";
+import type { SlashCommandBridgeMetadata, SlashCommandBridgeResult, SlashCommandExecutionContext } from "./lib/slash-command-bridge.js";
+
+declare module "@cwilson613/pi-coding-agent" {
+  interface RegisteredCommand {
+    bridge?: SlashCommandBridgeMetadata;
+    structuredExecutor?: (args: string, ctx: SlashCommandExecutionContext) => Promise<SlashCommandBridgeResult>;
+  }
+}

package/extensions/vault/index.ts

@@ -0,0 +1,185 @@
+/**
+ * vault — Markdown viewport extension
+ *
+ * Spawns mdserve to render interlinked project markdown as a navigable
+ * web UI with wikilink resolution, graph view, and live reload.
+ *
+ * Auto-starts mdserve on session_start if the binary is on $PATH.
+ * Stores port in sharedState for URI resolver consumption.
+ *
+ * Commands:
+ *   /vault           — Show status (running/stopped, port, PID)
+ *   /vault [path]    — Start mdserve on a specific directory
+ *   /vault stop      — Stop the running mdserve instance
+ *   /vault graph     — Open the graph view in the browser
+ */
+
+import { execSync, spawn, type ChildProcess } from "node:child_process";
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+const DEFAULT_PORT = 3333;
+const BINARY_NAME = "mdserve";
+
+let mdserveProcess: ChildProcess | null = null;
+let mdservePort: number | null = null;
+let mdserveDir: string | null = null;
+
+/** Get the current mdserve port, or null if not running. Used by uri-resolver. */
+export function getMdservePort(): number | null {
+	return mdservePort;
+}
+
+function hasBinary(): boolean {
+	try {
+		execSync(`which ${BINARY_NAME}`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function openBrowser(url: string): void {
+	try {
+		const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+		spawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+	} catch { /* user can open manually */ }
+}
+
+// No shared state update needed — getMdservePort() is the public API
+
+function stopMdserve(): string {
+	if (mdserveProcess) {
+		const pid = mdserveProcess.pid;
+		mdserveProcess.kill("SIGTERM");
+		mdserveProcess = null;
+		const msg = `Stopped mdserve (PID ${pid}, was serving ${mdserveDir} on port ${mdservePort})`;
+		mdservePort = null;
+		mdserveDir = null;
+		
+		return msg;
+	}
+	return "mdserve is not running.";
+}
+
+function spawnMdserve(dir: string, port: number, options?: { silent?: boolean }): string {
+	if (mdserveProcess) {
+		if (mdserveDir === dir) {
+			return `mdserve already running at http://127.0.0.1:${mdservePort} (PID ${mdserveProcess.pid})\n` +
+				`Serving: ${mdserveDir}\n` +
+				`Use \`/vault stop\` to stop, or \`/vault graph\` to open graph view.`;
+		}
+		stopMdserve();
+	}
+
+	const child = spawn(BINARY_NAME, [dir, "--port", String(port)], {
+		stdio: ["ignore", "pipe", "pipe"],
+		detached: false,
+	});
+
+	mdserveProcess = child;
+	mdservePort = port;
+	mdserveDir = dir;
+	
+
+	child.stdout?.on("data", (data: Buffer) => {
+		const match = data.toString().match(/using (\d+) instead/);
+		if (match) {
+			mdservePort = parseInt(match[1], 10);
+			
+		}
+	});
+
+	child.on("exit", () => {
+		if (mdserveProcess === child) {
+			mdserveProcess = null;
+			mdservePort = null;
+			mdserveDir = null;
+			
+		}
+	});
+
+	if (!options?.silent) {
+		openBrowser(`http://127.0.0.1:${port}`);
+	}
+
+	const prefix = options?.silent ? "Auto-started" : "Started";
+	return `${prefix} mdserve at http://127.0.0.1:${port} (PID ${child.pid})\n` +
+		`Serving: ${dir}\n` +
+		`Graph view: http://127.0.0.1:${port}/graph\n` +
+		`Use \`/vault stop\` to stop.`;
+}
+
+const NOT_INSTALLED = "`mdserve` is not installed. Run `/bootstrap` to set up Omegon dependencies.";
+
+export default function (pi: ExtensionAPI) {
+	
+
+	// Auto-start mdserve on session start if binary is available
+	pi.on("session_start", () => {
+		if (hasBinary()) {
+			spawnMdserve(process.cwd(), DEFAULT_PORT, { silent: true });
+		}
+	});
+
+	pi.on("session_shutdown", () => {
+		if (mdserveProcess) {
+			mdserveProcess.kill("SIGTERM");
+			mdserveProcess = null;
+			mdservePort = null;
+			mdserveDir = null;
+			
+		}
+	});
+
+	pi.registerCommand("vault", {
+		description: "Markdown viewport — serve project docs with wikilinks and graph view",
+		handler: async (args, ctx) => {
+			const subcommand = args.trim().split(/\s+/)[0]?.toLowerCase() || "";
+
+			switch (subcommand) {
+				case "stop":
+					ctx.ui.notify(stopMdserve(), "info");
+					return;
+
+				case "status":
+				case "": {
+					// Default: show status
+					if (mdserveProcess) {
+						ctx.ui.notify(
+							`mdserve is running (PID ${mdserveProcess.pid})\n` +
+							`URL: http://127.0.0.1:${mdservePort}\n` +
+							`Serving: ${mdserveDir}`,
+							"info",
+						);
+					} else if (!hasBinary()) {
+						ctx.ui.notify(NOT_INSTALLED, "warning");
+					} else {
+						ctx.ui.notify("mdserve is not running. Use `/vault [path]` to start.", "info");
+					}
+					return;
+				}
+
+				case "graph":
+					if (!hasBinary()) { ctx.ui.notify(NOT_INSTALLED, "warning"); return; }
+					if (mdserveProcess && mdservePort) {
+						openBrowser(`http://127.0.0.1:${mdservePort}/graph`);
+						ctx.ui.notify(`Opened graph view at http://127.0.0.1:${mdservePort}/graph`, "info");
+					} else {
+						const dir = process.cwd();
+						ctx.ui.notify(spawnMdserve(dir, DEFAULT_PORT), "info");
+						setTimeout(() => {
+							if (mdservePort) openBrowser(`http://127.0.0.1:${mdservePort}/graph`);
+						}, 1000);
+					}
+					return;
+
+				default: {
+					if (!hasBinary()) { ctx.ui.notify(NOT_INSTALLED, "warning"); return; }
+					const dir = subcommand;
+					ctx.ui.notify(spawnMdserve(dir, DEFAULT_PORT), "info");
+					return;
+				}
+			}
+		},
+	});
+}

package/extensions/version-check.ts

@@ -0,0 +1,90 @@
+/**
+ * version-check — Polls GitHub for new Omegon releases and notifies the operator.
+ *
+ * Checks on session start, then hourly. Compares the installed version
+ * (from package.json) against the latest GitHub release tag. If a newer
+ * version is found, sends a notification suggesting `pi update`.
+ *
+ * Respects PI_SKIP_VERSION_CHECK and PI_OFFLINE environment variables.
+ */
+
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_OWNER = "cwilson613";
+const REPO_NAME = "omegon";
+const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const FETCH_TIMEOUT_MS = 10_000;
+
+/** Read installed version from package.json */
+function getInstalledVersion(): string {
+  const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.version;
+}
+
+/** Fetch the latest release tag from GitHub. Returns version string or null. */
+async function fetchLatestRelease(): Promise<string | null> {
+  if (process.env.PI_SKIP_VERSION_CHECK || process.env.PI_OFFLINE) return null;
+
+  try {
+    const response = await fetch(
+      `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest`,
+      {
+        headers: { Accept: "application/vnd.github+json" },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      },
+    );
+    if (!response.ok) return null;
+    const data = (await response.json()) as { tag_name?: string };
+    return data.tag_name?.replace(/^v/, "") ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Simple semver comparison. Returns true if latest > current. */
+function isNewer(latest: string, current: string): boolean {
+  const parse = (v: string) => v.split(".").map((n) => parseInt(n, 10) || 0);
+  const l = parse(latest);
+  const c = parse(current);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+export default function versionCheck(pi: ExtensionAPI) {
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let notifiedVersion: string | null = null;
+
+  async function check() {
+    const installed = getInstalledVersion();
+    const latest = await fetchLatestRelease();
+    if (!latest || !isNewer(latest, installed)) return;
+    if (latest === notifiedVersion) return; // don't spam
+
+    notifiedVersion = latest;
+    pi.sendMessage({
+      customType: "view",
+      content: `**Omegon update available:** v${installed} → v${latest}\n\nRun \`pi update\` to upgrade.`,
+      display: true,
+    });
+  }
+
+  pi.on("session_start", async () => {
+    // Fire-and-forget — don't block session start
+    check();
+    timer = setInterval(check, CHECK_INTERVAL_MS);
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  });
+}