omegon 0.6.0

package/extensions/debug.ts

@@ -0,0 +1,69 @@
+/**
+ * Shared debug logging for Omegon extensions.
+ *
+ * Output goes to a log file (~/.pi/agent/omegon-debug.log) so it doesn't
+ * corrupt the TUI. Tail the file in a separate terminal to watch live:
+ *   tail -f ~/.pi/agent/omegon-debug.log
+ *
+ * Controlled by PI_DEBUG environment variable:
+ *   PI_DEBUG=1           — all extensions
+ *   PI_DEBUG=dashboard   — only dashboard
+ *   PI_DEBUG=openspec,cleave — comma-separated list
+ *
+ * Each log line: [HH:mm:ss.SSS scope:tag] {json}
+ */
+
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const PI_DEBUG = process.env.PI_DEBUG ?? "";
+const debugAll = PI_DEBUG === "1" || PI_DEBUG === "*" || PI_DEBUG === "true";
+const debugScopes = new Set(
+  debugAll ? [] : PI_DEBUG.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean),
+);
+
+const LOG_DIR = join(homedir(), ".pi", "agent");
+const LOG_PATH = join(LOG_DIR, "omegon-debug.log");
+let dirEnsured = false;
+
+function ensureDir(): void {
+  if (dirEnsured) return;
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+  } catch {
+    // best effort
+  }
+  dirEnsured = true;
+}
+
+function isEnabled(scope: string): boolean {
+  if (debugAll) return true;
+  if (debugScopes.size === 0) return false;
+  return debugScopes.has(scope.toLowerCase());
+}
+
+/** Path to the debug log file, for display to users. */
+export const DEBUG_LOG_PATH = LOG_PATH;
+
+/**
+ * Log a debug message to the Omegon debug log file.
+ *
+ * @param scope - Extension name (e.g. "dashboard", "openspec", "cleave")
+ * @param tag - Sub-tag for the message (e.g. "render", "emitState", "session_start")
+ * @param data - Optional structured data to include
+ */
+export function debug(scope: string, tag: string, data?: Record<string, unknown>): void {
+  if (!isEnabled(scope)) return;
+  ensureDir();
+  const ts = new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS
+  const prefix = `[${ts} ${scope}:${tag}]`;
+  const line = data && Object.keys(data).length > 0
+    ? `${prefix} ${JSON.stringify(data)}\n`
+    : `${prefix}\n`;
+  try {
+    appendFileSync(LOG_PATH, line);
+  } catch {
+    // best effort — don't crash extensions over logging
+  }
+}

package/extensions/defaults.ts

@@ -0,0 +1,282 @@
+/**
+ * defaults — Auto-configure Omegon defaults on first install
+ *
+ * - Sets theme to "default" if no theme is configured
+ * - Deploys global AGENTS.md to ~/.pi/agent/ for cross-project directives
+ *
+ * Guards:
+ * - Only writes settings/AGENTS.md if not already present or if managed by Omegon
+ * - Never overwrites a user-authored AGENTS.md (detected by absence of marker comment)
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+/**
+ * Resolve the agent directory the same way pi's getAgentDir() does.
+ * In standalone mode (PI_CODING_AGENT_DIR set to omegon root) this points
+ * directly at the omegon repo, so theme/AGENTS.md deployment becomes
+ * identity copies and is skipped by the content-equality guards.
+ */
+const home = process.env.HOME || process.env.USERPROFILE || "~";
+const AGENT_DIR = (() => {
+  const env = process.env.PI_CODING_AGENT_DIR;
+  if (env) {
+    if (env === "~") return home;
+    if (env.startsWith("~/")) return path.join(home, env.slice(2));
+    return env;
+  }
+  return path.join(home, ".pi", "agent");
+})();
+
+const SETTINGS_PATH = path.join(AGENT_DIR, "settings.json");
+const GLOBAL_AGENTS_PATH = path.join(AGENT_DIR, "AGENTS.md");
+const THEMES_DIR = path.join(AGENT_DIR, "themes");
+
+/** Themes shipped with Omegon — deployed to ~/.pi/agent/themes/ */
+const BUNDLED_THEMES = ["alpharius.json"] as const;
+
+/** Marker embedded in the deployed AGENTS.md to identify Omegon ownership */
+const PIKIT_MARKER = "<!-- managed by omegon -->";
+const PIKIT_MARKER_LEGACY = "<!-- managed by pi-kit -->"; // legacy — still treated as owned
+
+/** Hash file tracks the last content we deployed, so we detect user edits */
+const HASH_PATH = path.join(AGENT_DIR, ".agents-md-hash");
+
+/** Path to the template shipped with the Omegon package */
+const TEMPLATE_PATH = path.join(import.meta.dirname, "..", "config", "AGENTS.md");
+
+function contentHash(content: string): string {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+/**
+ * Alpharius palette anchor values — must stay in sync with themes/alpharius.json vars.
+ * Emitted via OSC 10/11 to clamp the terminal's native fg/bg so that pi-tui's full
+ * \x1b[0m line-resets fall through to Alpharius colors rather than the user's terminal theme.
+ *
+ * OSC 10 = set default foreground color
+ * OSC 11 = set default background color
+ * OSC 110/111 = restore saved fg/bg (most terminals support this as a reset)
+ *
+ * Kitty DOES honor OSC 10/11 (confirmed experimentally — overrides conf-based bg at runtime).
+ * All modern terminals (Kitty, iTerm2, WezTerm, Alacritty, foot, VTE, xterm) respect these.
+ */
+const ALPHARIUS_FG = "#c4d8e4";
+const ALPHARIUS_BG = "#02030a";
+
+function emitOsc10_11(fg: string, bg: string): void {
+  process.stdout.write(`\x1b]10;${fg}\x07\x1b]11;${bg}\x07`);
+}
+
+function restoreTerminalColors(): void {
+  // OSC 110 = restore saved default foreground, OSC 111 = restore saved default background
+  process.stdout.write("\x1b]110\x07\x1b]111\x07");
+}
+
+/** Ownership marker written by scripts/export-kitty-theme.ts into alpharius.conf */
+const KITTY_OWNERSHIP_MARKER = "# Generated from themes/alpharius.json by scripts/export-kitty-theme.ts";
+
+/** Installed location — standard Kitty themes directory */
+const KITTY_CONF_PATH = path.join(
+  process.env.HOME || process.env.USERPROFILE || "~",
+  ".config", "kitty", "themes", "alpharius.conf",
+);
+
+/** Source of truth shipped with Omegon */
+const KITTY_CONF_SRC = path.join(import.meta.dirname, "..", "themes", "alpharius.conf");
+
+let kittyWarnedThisSession = false;
+
+/**
+ * Gently sync alpharius.conf to Kitty's themes directory.
+ *
+ * Rules:
+ *  - File missing          → install it, notify
+ *  - File present, owned   → update if stale, notify with reload hint
+ *  - File present, unowned → warn once, never touch
+ */
+function syncKittyTheme(notify: (msg: string, level: "info" | "warning") => void): void {
+  try {
+    if (!fs.existsSync(KITTY_CONF_SRC)) return;
+    const srcContent = fs.readFileSync(KITTY_CONF_SRC, "utf8");
+
+    if (!fs.existsSync(KITTY_CONF_PATH)) {
+      // Not installed — write it
+      fs.mkdirSync(path.dirname(KITTY_CONF_PATH), { recursive: true });
+      fs.writeFileSync(KITTY_CONF_PATH, srcContent, "utf8");
+      notify("Omegon: installed alpharius.conf to Kitty themes — add `include themes/alpharius.conf` to kitty.conf", "info");
+      return;
+    }
+
+    const existing = fs.readFileSync(KITTY_CONF_PATH, "utf8");
+
+    if (!existing.includes(KITTY_OWNERSHIP_MARKER)) {
+      // User-authored — don't touch, warn once
+      if (!kittyWarnedThisSession) {
+        kittyWarnedThisSession = true;
+        notify(
+          "Omegon: ~/.config/kitty/themes/alpharius.conf exists but wasn't generated by Omegon — skipping update",
+          "warning",
+        );
+      }
+      return;
+    }
+
+    if (existing !== srcContent) {
+      // Owned and stale — update
+      fs.writeFileSync(KITTY_CONF_PATH, srcContent, "utf8");
+      notify("Omegon: Kitty theme updated — reload with Ctrl+Shift+F5", "info");
+    }
+    // else: up to date — no-op
+  } catch {
+    // Best effort
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    // --- Terminal color anchoring (OSC 10/11) ---
+    // Clamp the terminal's native fg/bg to Alpharius values so that pi-tui's \x1b[0m
+    // line-resets (hardcoded in pi-tui applyLineResets) don't bleed through a
+    // lighter/different terminal background. OSC 10/11 works on all modern terminals
+    // including Kitty (confirmed — overrides conf-based colors at runtime).
+    emitOsc10_11(ALPHARIUS_FG, ALPHARIUS_BG);
+
+    // Belt-and-suspenders: if Kitty remote control is available, also push via @ set-colors.
+    // This survives cases where OSC sequences are swallowed by multiplexers.
+    try {
+      const { execSync } = await import("child_process");
+      execSync(`kitty @ set-colors background=${ALPHARIUS_BG} foreground=${ALPHARIUS_FG}`, {
+        timeout: 1000, stdio: "ignore",
+      });
+    } catch { /* not Kitty or remote control disabled — OSC 10/11 covers it */ }
+
+    // --- Kitty theme sync ---
+    if (ctx.hasUI) {
+      syncKittyTheme((msg, level) => ctx.ui.notify(msg, level));
+    } else {
+      syncKittyTheme(() => {}); // silent in non-UI mode (e.g. pi -p children)
+    }
+
+    // --- Terminal tab title branding ---
+    // Replace the core π symbol with Ω in the terminal tab title.
+    // This fires after the core title is set, so it overwrites it.
+    if (ctx.hasUI) {
+      const sessionName = ctx.sessionManager.getSessionName();
+      const cwdBasename = path.basename(ctx.cwd);
+      const title = sessionName
+        ? `Ω - ${sessionName} - ${cwdBasename}`
+        : `Ω - ${cwdBasename}`;
+      ctx.ui.setTitle(title);
+    }
+
+    // --- Theme default ---
+    try {
+      const raw = fs.readFileSync(SETTINGS_PATH, "utf8");
+      const settings = JSON.parse(raw);
+
+      let changed = false;
+
+      // Always enforce alpharius — Omegon is opinionated about its own TUI.
+      // Override "default" and absent theme; leave other explicit choices alone.
+      if (!settings.theme || settings.theme === "default") {
+        settings.theme = "alpharius";
+        changed = true;
+      }
+
+      if (changed) {
+        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf8");
+        if (ctx.hasUI) {
+          ctx.ui.notify("Omegon: activated alpharius theme (restart pi to apply)", "info");
+        }
+      }
+    } catch {
+      // Best effort
+    }
+
+    // --- Theme deployment ---
+    // Copy bundled themes to ~/.pi/agent/themes/, overwriting on every session start
+    // so updates in the repo propagate automatically.
+    try {
+      fs.mkdirSync(THEMES_DIR, { recursive: true });
+      for (const themeFile of BUNDLED_THEMES) {
+        const src = path.join(import.meta.dirname, "..", "themes", themeFile);
+        const dst = path.join(THEMES_DIR, themeFile);
+        if (!fs.existsSync(src)) continue;
+        const srcContent = fs.readFileSync(src, "utf8");
+        const dstContent = fs.existsSync(dst) ? fs.readFileSync(dst, "utf8") : null;
+        if (srcContent !== dstContent) {
+          fs.writeFileSync(dst, srcContent, "utf8");
+          if (ctx.hasUI) {
+            ctx.ui.notify(`Omegon: updated theme ${themeFile} (restart to apply)`, "info");
+          }
+        }
+      }
+    } catch {
+      // Best effort
+    }
+
+    // --- Global AGENTS.md deployment ---
+    try {
+      if (!fs.existsSync(TEMPLATE_PATH)) return;
+      fs.mkdirSync(AGENT_DIR, { recursive: true });
+      const template = fs.readFileSync(TEMPLATE_PATH, "utf8");
+      const deployContent = `${template.trimEnd()}\n\n${PIKIT_MARKER}\n`;
+
+      if (fs.existsSync(GLOBAL_AGENTS_PATH)) {
+        const existing = fs.readFileSync(GLOBAL_AGENTS_PATH, "utf8");
+
+        if (existing.includes(PIKIT_MARKER) || existing.includes(PIKIT_MARKER_LEGACY)) {
+          // We own this file — check if user has edited it since last deploy
+          if (existing !== deployContent) {
+            const lastHash = fs.existsSync(HASH_PATH) ? fs.readFileSync(HASH_PATH, "utf8").trim() : null;
+            const existingHash = contentHash(existing);
+
+            if (!lastHash) {
+              // First run with hash tracking — adopt current content as baseline
+              // so we don't overwrite edits made before the hash mechanism existed
+              fs.writeFileSync(HASH_PATH, existingHash, "utf8");
+              if (ctx.hasUI) {
+                ctx.ui.notify(
+                  "Omegon: AGENTS.md template updated. Changes will apply on next session start.",
+                  "info",
+                );
+              }
+            } else if (lastHash !== existingHash) {
+              // File was modified externally — warn, don't overwrite
+              if (ctx.hasUI) {
+                ctx.ui.notify(
+                  "Omegon: ~/.pi/agent/AGENTS.md has local edits. Remove the omegon marker to keep them, or delete the file to re-deploy.",
+                  "warning",
+                );
+              }
+            } else {
+              // File matches our last deploy — safe to update
+              fs.writeFileSync(GLOBAL_AGENTS_PATH, deployContent, "utf8");
+              fs.writeFileSync(HASH_PATH, contentHash(deployContent), "utf8");
+            }
+          }
+        }
+        // else: user-authored file (no marker), don't touch it
+      } else {
+        // No AGENTS.md exists — deploy ours
+        fs.writeFileSync(GLOBAL_AGENTS_PATH, deployContent, "utf8");
+        fs.writeFileSync(HASH_PATH, contentHash(deployContent), "utf8");
+        if (ctx.hasUI) {
+          ctx.ui.notify("Omegon: deployed global directives to ~/.pi/agent/AGENTS.md", "info");
+        }
+      }
+    } catch {
+      // Best effort — don't break startup
+    }
+  });
+
+  pi.on("session_shutdown", async () => {
+    // Restore the terminal's original fg/bg on exit so the user's shell prompt
+    // and other programs see their own configured colors again.
+    restoreTerminalColors();
+  });
+}

package/extensions/design-tree/dashboard-state.ts

@@ -0,0 +1,161 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import type { ExtensionAPI } from "@cwilson613/pi-coding-agent";
+
+import type { DesignNode, DesignTree } from "./types.ts";
+import { getAllOpenQuestions, countAcceptanceCriteria } from "./tree.ts";
+import { sharedState, DASHBOARD_UPDATE_EVENT } from "../shared-state.ts";
+import type { DesignTreeDashboardState } from "../shared-state.ts";
+import type { DesignAssessmentResult, DesignPipelineCounts } from "../dashboard/types.ts";
+import type { DesignSpecBinding } from "../openspec/archive-gate.ts";
+import { debug } from "../debug.ts";
+
+/** Read assessment.json from openspec/design/<id>/assessment.json if it exists. */
+function readAssessmentResult(cwd: string, nodeId: string): DesignAssessmentResult | null {
+	const assessmentPath = path.join(cwd, "openspec", "design", nodeId, "assessment.json");
+	if (!fs.existsSync(assessmentPath)) return null;
+	try {
+		const raw = JSON.parse(fs.readFileSync(assessmentPath, "utf-8"));
+		return {
+			outcome: raw.outcome ?? "ambiguous",
+			timestamp: raw.timestamp ?? "",
+			summary: raw.summary,
+		};
+	} catch {
+		return null;
+	}
+}
+
+/** Build archivedIds Set by scanning openspec/design-archive/ exactly once. */
+function buildArchivedIds(cwd: string): Set<string> {
+	const archiveDir = path.join(cwd, "openspec", "design-archive");
+	const ids = new Set<string>();
+	if (!fs.existsSync(archiveDir)) return ids;
+	for (const entry of fs.readdirSync(archiveDir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		const match = entry.name.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
+		if (match) ids.add(match[1]);
+	}
+	return ids;
+}
+
+/** Inline binding resolver that uses a pre-built archivedIds set — no extra readdirSync. */
+function resolveBindingInline(cwd: string, nodeId: string, archivedIds: Set<string>): DesignSpecBinding {
+	const designDir = path.join(cwd, "openspec", "design", nodeId);
+	const active =
+		fs.existsSync(designDir) &&
+		fs.statSync(designDir).isDirectory() &&
+		fs.readdirSync(designDir).length > 0;
+	const archived = archivedIds.has(nodeId);
+	return { active, archived: archived && !active, missing: !active && !archived };
+}
+
+export function emitDesignTreeState(pi: ExtensionAPI, dt: DesignTree, focused: DesignNode | null): void {
+	if (dt.nodes.size === 0) return;
+	const cwd = process.cwd();
+	const allNodes = Array.from(dt.nodes.values());
+	// Exclude implemented nodes from the active dashboard view — they're done work.
+	// Deferred nodes remain visible: they are future work, not OBE.
+	const nodes = allNodes.filter((n) => n.status !== "implemented");
+
+	// C1 fix: scan design-archive once outside the map loop.
+	const archivedIds = buildArchivedIds(cwd);
+
+	// Compute design pipeline funnel counts across ALL nodes
+	const pipelineCounts: DesignPipelineCounts = {
+		needsSpec: 0,
+		designing: 0,
+		decided: 0,
+		implementing: 0,
+		done: allNodes.filter((n) => n.status === "implemented").length,
+	};
+
+	const NEUTRAL_SENTINEL: DesignSpecBinding = { active: false, archived: false, missing: false };
+
+	const enrichedNodes = nodes.map((n) => {
+		const isSeedLike = n.status === "seed";
+		const isActivePhase = ["exploring", "decided", "implementing"].includes(n.status);
+		// W3 fix: deferred/blocked also receive the neutral sentinel (not undefined)
+		const isPassive = n.status === "deferred" || n.status === "blocked";
+
+		// Resolve binding for non-seed nodes
+		let designSpec: DesignSpecBinding;
+		let acSummary: ReturnType<typeof countAcceptanceCriteria> | null = null;
+		let assessmentResult: DesignAssessmentResult | null = null;
+
+		if (isSeedLike || isPassive) {
+			// Seeds/deferred/blocked have no active binding — emit neutral sentinel
+			designSpec = NEUTRAL_SENTINEL;
+		} else {
+			// isActivePhase: exploring, decided, implementing
+			// C1 fix: use inline resolver with pre-built archivedIds
+			designSpec = resolveBindingInline(cwd, n.id, archivedIds);
+			acSummary = countAcceptanceCriteria(n);
+			assessmentResult = readAssessmentResult(cwd, n.id);
+		}
+
+		// Accumulate pipeline counts
+		// C3 fix: deferred/blocked fall into needsSpec so funnel totals reconcile
+		if (n.status === "decided") {
+			pipelineCounts.decided++;
+		} else if (n.status === "implementing") {
+			pipelineCounts.implementing++;
+		} else if (n.status === "exploring" || n.status === "seed") {
+			const bound = designSpec.active || designSpec.archived;
+			if (bound) {
+				pipelineCounts.designing++;
+			} else {
+				pipelineCounts.needsSpec++;
+			}
+		} else {
+			// deferred / blocked — no spec yet, count as needsSpec
+			pipelineCounts.needsSpec++;
+		}
+
+		return {
+			id: n.id,
+			title: n.title,
+			status: n.status,
+			questionCount: n.open_questions.length,
+			filePath: n.filePath,
+			branches: n.branches ?? [],
+			openspecChange: n.openspec_change ?? null,
+			designSpec,
+			acSummary,
+			assessmentResult,
+		};
+	});
+
+	const state: DesignTreeDashboardState = {
+		// W1 fix: nodeCount reflects ALL nodes so implementedCount/nodeCount ratios are correct
+		nodeCount: allNodes.length,
+		decidedCount: nodes.filter((n) => n.status === "decided").length,
+		exploringCount: nodes.filter((n) => n.status === "exploring" || n.status === "seed").length,
+		implementingCount: nodes.filter((n) => n.status === "implementing").length,
+		implementedCount: allNodes.filter((n) => n.status === "implemented").length,
+		blockedCount: nodes.filter((n) => n.status === "blocked").length,
+		deferredCount: nodes.filter((n) => n.status === "deferred").length,
+		openQuestionCount: getAllOpenQuestions(dt).length,
+		focusedNode: focused
+			? {
+					id: focused.id,
+					title: focused.title,
+					status: focused.status,
+					questions: [...focused.open_questions],
+					branch: focused.branches?.[0],
+					branchCount: focused.branches?.length ?? 0,
+					filePath: focused.filePath,
+				}
+			: null,
+		nodes: enrichedNodes,
+		implementingNodes: nodes
+			.filter((n) => n.status === "implementing")
+			.map((n) => ({ id: n.id, title: n.title, branch: n.branches?.[0], filePath: n.filePath })),
+		designPipeline: pipelineCounts,
+	};
+
+	sharedState.designTree = state;
+	debug("design-tree", "emitState", { nodeCount: nodes.length, decided: state.decidedCount, exploring: state.exploringCount });
+	pi.events.emit(DASHBOARD_UPDATE_EVENT, { source: "design-tree" });
+}