@openlines/opl-pi-sht 0.1.14

package/extensions/opl-footer/segments/model.ts

@@ -0,0 +1,22 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+import { color } from "./helpers.js";
+
+export const modelSegment = {
+  id: "model" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    let modelName = ctx.model?.name || ctx.model?.id || "no-model";
+
+    if (modelName.startsWith("Claude ")) {
+      modelName = modelName.slice(7);
+    }
+
+    let content = color(ctx, "model", modelName);
+
+    if (ctx.model?.provider) {
+      content += ` ${applyColor(ctx.theme, "dim", `(${ctx.model.provider})`)}`;
+    }
+
+    return { content, visible: true };
+  },
+};

package/extensions/opl-footer/segments/path.ts

@@ -0,0 +1,34 @@
+import { basename } from "node:path";
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { color, withIcon } from "./helpers.js";
+
+export const pathSegment = {
+  id: "path" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const opts = ctx.options.path ?? {};
+    const mode = opts.mode ?? "basename";
+
+    let pwd = process.cwd();
+    const home = process.env.HOME || process.env.USERPROFILE;
+
+    if (mode === "basename") {
+      pwd = basename(pwd) || pwd;
+    } else {
+      if (home && pwd.startsWith(home)) {
+        pwd = `~${pwd.slice(home.length)}`;
+      }
+      if (pwd.startsWith("/work/")) {
+        pwd = pwd.slice(6);
+      }
+      if (mode === "abbreviated") {
+        const maxLen = opts.maxLength ?? 40;
+        if (pwd.length > maxLen) {
+          pwd = `…${pwd.slice(-(maxLen - 1))}`;
+        }
+      }
+    }
+
+    const content = withIcon(ctx.icons.folder, pwd);
+    return { content: color(ctx, "path", content), visible: true };
+  },
+};

package/extensions/opl-footer/segments/pi.ts

@@ -0,0 +1,11 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { color } from "./helpers.js";
+
+export const piSegment = {
+  id: "pi" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    if (!ctx.icons.pi) return { content: "", visible: false };
+    const content = `${ctx.icons.pi} `;
+    return { content: color(ctx, "pi", content), visible: true };
+  },
+};

package/extensions/opl-footer/segments/plan-mode.ts

@@ -0,0 +1,24 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+import { color } from "./helpers.js";
+
+interface PlanModeState {
+  mode: string;
+}
+
+function readPlanModeState(): PlanModeState | undefined {
+  return (globalThis as Record<string, unknown>).__planMode as PlanModeState | undefined;
+}
+
+export const planModeSegment = {
+  id: "plan_mode" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const state = readPlanModeState();
+    if (!state) return { content: "", visible: false };
+
+    const label = applyColor(ctx.theme, "dim", "Plan mode:");
+    const value = state.mode === "off" ? "OFF" : "ON";
+
+    return { content: `${label} ${color(ctx, "modeIndicator", value)}`, visible: true };
+  },
+};

package/extensions/opl-footer/segments/separator.ts

@@ -0,0 +1,9 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { color } from "./helpers.js";
+
+export const separatorSegment = {
+  id: "separator" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    return { content: color(ctx, "separator", ctx.icons.separator), visible: true };
+  },
+};

package/extensions/opl-footer/segments/session-stats.ts

@@ -0,0 +1,82 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+
+function dim(ctx: SegmentContext, s: string): string {
+  return applyColor(ctx.theme, "dim", s);
+}
+
+function val(ctx: SegmentContext, s: string): string {
+  return applyColor(ctx.theme, "text", s);
+}
+
+export function formatMs(ms: number): string {
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const m = Math.floor(ms / 60_000);
+  const s = Math.round((ms % 60_000) / 1000);
+  return `${m}m ${s}s`;
+}
+
+export const sessionStatsSegment = {
+  id: "session_stats" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const { turns, steps, modelRequests, modelToolCalls } = ctx.sessionStats;
+    if (turns === 0) return { content: "", visible: false };
+
+    const parts: string[] = [
+      val(ctx, `${turns}`) + dim(ctx, " turns"),
+      val(ctx, `${steps}`) + dim(ctx, " steps"),
+    ];
+
+    // Add model stats if available
+    if (modelRequests > 0) {
+      parts.push(val(ctx, `${modelRequests}`) + dim(ctx, " mreq"));
+    }
+    if (modelToolCalls > 0) {
+      parts.push(val(ctx, `${modelToolCalls}`) + dim(ctx, " mtool"));
+    }
+
+    return { content: parts.join(dim(ctx, " · ")), visible: true };
+  },
+};
+
+export const perfStatsSegment = {
+  id: "perf_stats" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const { turns, llmMs, toolMs, ttftSamples, lastTurnaroundMs } = ctx.sessionStats;
+    if (turns === 0) return { content: "", visible: false };
+
+    const { input, output, cacheRead } = ctx.usageStats;
+
+    const parts: string[] = []
+
+    // LLM (last-turn TAT) · Tool time
+    const tat = lastTurnaroundMs > 0
+      ? dim(ctx, " (") + val(ctx, formatMs(lastTurnaroundMs)) + dim(ctx, ")")
+      : "";
+    parts.push(
+      dim(ctx, "LLM ") + val(ctx, formatMs(llmMs)) + tat +
+      dim(ctx, " · Tool ") + val(ctx, formatMs(toolMs)),
+    );
+
+    // TTFT avg · tok/s
+    const ttftAvg = ttftSamples.length > 0
+      ? ttftSamples.reduce((a, b) => a + b, 0) / ttftSamples.length
+      : 0;
+    const tokPerSec = llmMs > 0 ? Math.round(output / (llmMs / 1000)) : 0;
+    if (ttftAvg > 0 || tokPerSec > 0) {
+      parts.push(
+        dim(ctx, "TTFT ") + val(ctx, `${(ttftAvg / 1000).toFixed(1)}s`) +
+        dim(ctx, " · ") + val(ctx, `${tokPerSec}`) + dim(ctx, " tok/s"),
+      );
+    }
+
+    // Cache hit %
+    const total = input + cacheRead;
+    if (total > 0 && cacheRead > 0) {
+      const pct = Math.round((cacheRead / total) * 100);
+      parts.push(dim(ctx, "Cache ") + val(ctx, `${pct}%`));
+    }
+
+    return { content: parts.join(dim(ctx, " | ")), visible: true };
+  },
+};

package/extensions/opl-footer/segments/thinking.ts

@@ -0,0 +1,51 @@
+import type { RenderedSegment, SegmentContext, SemanticColor } from "../types.js";
+import { applyColor, rainbow } from "../theme.js";
+
+const LEVEL_CAPS: Record<string, string> = {
+  off: "OFF",
+  minimal: "MINIMAL",
+  low: "LOW",
+  medium: "MEDIUM",
+  high: "HIGH",
+  xhigh: "EXTRA HIGH",
+  max: "MAX",
+};
+
+const LEVEL_COLOR_KEY: Record<string, SemanticColor> = {
+  off: "thinkingOff",
+  minimal: "thinkingMinimal",
+  low: "thinkingLow",
+  medium: "thinkingMedium",
+  high: "thinkingHigh",
+  // xhigh/max absent from DEFAULT_COLORS — presence here enables user override
+  xhigh: "thinkingXhigh",
+  max: "thinkingMax",
+};
+
+const LEVEL_COLOR_FALLBACK: Record<string, string> = {
+  off: "dim",
+  minimal: "muted",
+  low: "warning",
+  medium: "success",
+  high: "#afb9fe",
+};
+
+export const thinkingSegment = {
+  id: "thinking" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const level = ctx.thinkingLevel || "off";
+
+    const label = applyColor(ctx.theme, "dim", "Thinking:");
+    const text = LEVEL_CAPS[level] || level.toUpperCase();
+
+    const colorKey = LEVEL_COLOR_KEY[level];
+    const configured = colorKey !== undefined ? ctx.colors[colorKey] : undefined;
+    const textColor = configured ?? LEVEL_COLOR_FALLBACK[level] ?? "muted";
+
+    // Rainbow is the default for xhigh/max; an explicit color config overrides it
+    const useRainbow = !configured && (level === "xhigh" || level === "max");
+    const coloredText = useRainbow ? rainbow(text) : applyColor(ctx.theme, textColor as any, text);
+
+    return { content: `${label} ${coloredText}`, visible: true };
+  },
+};

package/extensions/opl-footer/segments/tokens.ts

@@ -0,0 +1,66 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+import { color, formatTokens } from "./helpers.js";
+
+function lbl(ctx: SegmentContext, text: string): string {
+  return applyColor(ctx.theme, "dim", text);
+}
+
+function val(ctx: SegmentContext, text: string): string {
+  return color(ctx, "tokens", text);
+}
+
+export const tokenTotalSegment = {
+  id: "token_total" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const { input, output, cacheRead, cacheWrite } = ctx.usageStats;
+    const total = input + output + cacheRead + cacheWrite;
+    const cached = cacheRead + cacheWrite;
+
+    const content =
+      lbl(ctx, "T:") + " " + val(ctx, formatTokens(total)) +
+      " " + lbl(ctx, "(") + val(ctx, formatTokens(cached)) + lbl(ctx, " cached)") +
+      " " + lbl(ctx, "↑") + " " + val(ctx, formatTokens(input)) +
+      " " + lbl(ctx, "↓") + " " + val(ctx, formatTokens(output));
+
+    return { content, visible: true };
+  },
+};
+
+export const tokenInSegment = {
+  id: "token_in" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    return {
+      content: lbl(ctx, "↑") + " " + val(ctx, formatTokens(ctx.usageStats.input)),
+      visible: true,
+    };
+  },
+};
+
+export const tokenOutSegment = {
+  id: "token_out" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    return {
+      content: lbl(ctx, "↓") + " " + val(ctx, formatTokens(ctx.usageStats.output)),
+      visible: true,
+    };
+  },
+};
+
+export const cacheReadSegment = {
+  id: "cache_read" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const { cacheRead } = ctx.usageStats;
+    if (!cacheRead) return { content: "", visible: false };
+    return { content: val(ctx, formatTokens(cacheRead)), visible: true };
+  },
+};
+
+export const cacheWriteSegment = {
+  id: "cache_write" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const { cacheWrite } = ctx.usageStats;
+    if (!cacheWrite) return { content: "", visible: false };
+    return { content: val(ctx, formatTokens(cacheWrite)), visible: true };
+  },
+};

package/extensions/opl-footer/theme.ts

@@ -0,0 +1,113 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { ColorScheme, ColorValue, SemanticColor } from "./types.js";
+
+// Default color scheme — thinkingXhigh and thinkingMax are intentionally absent;
+// their absence signals "use rainbow" in thinking.ts.
+const DEFAULT_COLORS: ColorScheme = {
+  pi: "accent",
+  model: "#c07898",
+  path: "dim",
+  git: "success",
+  gitDirty: "warning",
+  gitClean: "success",
+  thinking: "muted",
+  thinkingOff: "dim",
+  thinkingMinimal: "muted",
+  thinkingLow: "warning",
+  thinkingMedium: "success",
+  thinkingHigh: "#afb9fe",
+  context: "dim",
+  contextWarn: "warning",
+  contextError: "error",
+  contextLabel: "muted",
+  cost: "muted",
+  tokens: "muted",
+  separator: "#4e4c49",
+  modeIndicator: "muted",
+};
+
+function isHexColor(color: ColorValue): color is `#${string}` {
+  return typeof color === "string" && color.startsWith("#");
+}
+
+function hexToAnsi(hex: string): string {
+  const h = hex.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(h)) return "";
+  const r = parseInt(h.slice(0, 2), 16);
+  const g = parseInt(h.slice(2, 4), 16);
+  const b = parseInt(h.slice(4, 6), 16);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+export function applyColor(
+  theme: Theme,
+  color: ColorValue,
+  text: string
+): string {
+  if (isHexColor(color)) {
+    return `${hexToAnsi(color)}${text}\x1b[0m`;
+  }
+  return theme.fg(color as ThemeColor, text);
+}
+
+export function fg(
+  theme: Theme,
+  semantic: SemanticColor,
+  text: string,
+  presetColors?: ColorScheme
+): string {
+  const color = presetColors?.[semantic] ?? DEFAULT_COLORS[semantic];
+  if (color === undefined) return text;
+  return applyColor(theme, color, text);
+}
+
+function hslToAnsi(h: number, s: number, l: number): string {
+  if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(l)) return "";
+  const a = s * Math.min(l, 1 - l);
+  const f = (n: number) => {
+    const k = (n + h / 30) % 12;
+    const v = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+    return Math.round(v * 255);
+  };
+  return `\x1b[38;2;${f(0)};${f(8)};${f(4)}m`;
+}
+
+// Spread hues evenly across all non-space characters
+export function rainbow(text: string): string {
+  const visibleChars = [...text].filter(c => c !== " " && c !== ":").length;
+  let result = "";
+  let colorIndex = 0;
+  for (const char of text) {
+    if (char === " " || char === ":") {
+      result += char;
+    } else {
+      const hue = (colorIndex / Math.max(visibleChars - 1, 1)) * 300;
+      result += hslToAnsi(hue, 0.85, 0.65) + char;
+      colorIndex++;
+    }
+  }
+  return result + "\x1b[0m";
+}
+
+export function getDefaultColors(): ColorScheme {
+  return { ...DEFAULT_COLORS };
+}
+
+// Resolve any ColorValue to an RGB triple for gradient math.
+// Named theme tokens are probed by applying them to a dummy string and parsing
+// the resulting ANSI 24-bit escape sequence. Returns null when the theme uses a
+// non-24-bit code (e.g. 256-colour or named colour) — callers should fall back.
+export function resolveColorToRgb(
+  theme: Theme,
+  color: ColorValue
+): { r: number; g: number; b: number } | null {
+  if (isHexColor(color)) {
+    const h = color.replace("#", "");
+    if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+    return { r: parseInt(h.slice(0, 2), 16), g: parseInt(h.slice(2, 4), 16), b: parseInt(h.slice(4, 6), 16) };
+  }
+  const probed = theme.fg(color as ThemeColor, "X");
+  const match = probed.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
+  if (!match) return null;
+  return { r: parseInt(match[1]), g: parseInt(match[2]), b: parseInt(match[3]) };
+}

package/extensions/opl-footer/types.ts

@@ -0,0 +1,172 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { IconSet } from "./icons.js";
+
+// Theme color - either a pi theme color name or a custom hex color
+export type ColorValue = ThemeColor | `#${string}`;
+
+// Semantic color names for segments
+export type SemanticColor =
+  | "pi"
+  | "model"
+  | "path"
+  | "git"
+  | "gitDirty"
+  | "gitClean"
+  | "thinking"
+  | "thinkingOff"
+  | "thinkingMinimal"
+  | "thinkingLow"
+  | "thinkingMedium"
+  | "thinkingHigh"
+  | "thinkingXhigh"
+  | "thinkingMax"
+  | "context"
+  | "contextWarn"
+  | "contextError"
+  | "contextLabel"
+  | "cost"
+  | "tokens"
+  | "separator"
+  | "modeIndicator";
+
+// Color scheme mapping semantic names to actual colors
+export type ColorScheme = Partial<Record<SemanticColor, ColorValue>>;
+
+// Segment identifiers
+export type StatusLineSegmentId =
+  | "pi"
+  | "model"
+  | "path"
+  | "git"
+  | "token_in"
+  | "token_out"
+  | "token_total"
+  | "cost"
+  | "context_pct"
+  | "context_total"
+  | "cache_read"
+  | "cache_write"
+  | "thinking"
+  | "caveman"
+  | "plan_mode"
+  | "chat_mode"
+  | "mode_switcher"
+  | "session_stats"
+  | "perf_stats"
+  | "separator"
+  | `text:${string}`;
+
+// Per-segment options
+export interface StatusLineSegmentOptions {
+  path?: {
+    mode?: "basename" | "abbreviated" | "full";
+    maxLength?: number;
+  };
+  git?: {
+    showBranch?: boolean;
+    showStaged?: boolean;
+    showUnstaged?: boolean;
+    showUntracked?: boolean;
+  };
+  contextBar?: {
+    barWidth?: number;
+    filledChar?: string;
+    unfilledChar?: string;
+    unfilledColor?: ColorValue;
+    gradientStart?: ColorValue;
+    gradientMid?: ColorValue;
+    gradientEnd?: ColorValue;
+    gradientMidPoint?: number;
+  };
+}
+
+// Git status data
+export interface GitStatus {
+  branch: string | null;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+}
+
+// Usage statistics
+export interface UsageStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+
+// Session performance stats accumulated via events
+export interface SessionStats {
+  turns: number;
+  steps: number;
+  modelRequests: number;
+  modelToolCalls: number;
+  llmMs: number;
+  toolMs: number;
+  ttftSamples: number[];
+  lastTurnaroundMs: number;
+}
+
+// Context passed to segment render functions
+export interface SegmentContext {
+  model: { id: string; name?: string; reasoning?: boolean; contextWindow?: number; provider?: string; baseUrl?: string } | undefined;
+  isLocalModel: boolean;
+  thinkingLevel: string;
+  sessionId: string | undefined;
+  usageStats: UsageStats;
+  contextPercent: number;
+  contextWindow: number;
+  usingSubscription: boolean;
+  sessionStartTime: number;
+  git: GitStatus;
+  options: StatusLineSegmentOptions;
+  width: number;
+  theme: Theme;
+  colors: ColorScheme;
+  icons: IconSet;
+  sessionStats: SessionStats;
+}
+
+// Minimal event shapes used by the opl-footer handlers
+export interface ToolResultEvent {
+  toolName: string;
+  input?: { command?: string };
+}
+
+export interface UserBashEvent {
+  command: string;
+}
+
+// Minimal session event shapes used for opl-footer stats
+export interface ThinkingLevelEvent {
+  type: "thinking_level_change";
+  thinkingLevel?: string;
+}
+
+export interface AssistantMessageEvent {
+  type: "message";
+  message: { role: string };
+}
+
+export type SessionEvent = ThinkingLevelEvent | AssistantMessageEvent | { type: string };
+
+// Rendered segment output
+export interface RenderedSegment {
+  content: string;
+  visible: boolean;
+}
+
+// User configuration from opl-footer.json
+export interface FooterUserConfig {
+  row1LeftSegments?: StatusLineSegmentId[];
+  row1RightSegments?: StatusLineSegmentId[];
+  row2LeftSegments?: StatusLineSegmentId[];
+  row2RightSegments?: StatusLineSegmentId[];
+  row3LeftSegments?: StatusLineSegmentId[];
+  row3RightSegments?: StatusLineSegmentId[];
+  colors?: ColorScheme;
+  segmentOptions?: StatusLineSegmentOptions;
+  icons?: Partial<IconSet>;
+}

package/extensions/opl-init/README.md

@@ -0,0 +1,23 @@
+# opl-init
+
+Generates or refreshes a repository-specific `AGENTS.md` guide through `/init`.
+
+## Commands, flags, and shortcuts
+
+- `/init`: crawl the current repository and create or update `AGENTS.md` when its fingerprint is missing or stale.
+- No flags or shortcuts.
+
+## Extension features
+
+- Produces evidence-based guidance for project purpose, commands, architecture, configuration, testing, operational quirks, and key files.
+- Crawls deterministically to depth 3, ignores generated/dependency directories, caps directory listings at 40 entries, and caps the rendered tree at 300 lines with explicit omission markers.
+- Re-walks declared `pnpm-workspace.yaml` and Cargo workspace members with their own depth-3 budget; reports `turbo.json` and `nx.json` as contextual manifests.
+- Collects extension counts, known manifests, and npm scripts without embedding full manifest bodies.
+- Incorporates relevant Cursor, Copilot, Claude Code, Windsurf, Cline, and Devin rule sources without copying them verbatim or treating them as more authoritative than repository evidence.
+- Writes a deterministic baseline `AGENTS.md` before dispatching the model turn, so lower-capability models cannot leave the guide only in chat; the model is then prompted to refine it with repository-specific guidance and verify the file.
+- Skips the model turn when the final `<!-- opl-init:fp <fingerprint> -->` marker is current.
+- Excludes `AGENTS.md` itself from the Git status fingerprint, preventing the act of updating the guide from making it immediately stale.
+
+## Architecture
+
+`index.ts` owns crawling, fingerprinting, baseline writing, foreign-rule discovery, and prompt dispatch. Git repositories fingerprint `HEAD` plus relevant `git status --porcelain=v1 --untracked-files=all` output, excluding `AGENTS.md` itself; non-Git repositories use sorted path, size, and mtime tuples. Crawl context remains in the active Pi transcript only; cross-session structured retrieval is not implemented. The model prompt explicitly requires a write-tool call and a read-back verification, but the baseline write is the reliability boundary.