supipowers 1.2.5 → 1.3.0

package/src/config/model-resolver.ts

@@ -111,3 +111,90 @@ export function createModelBridge(platform: Platform): ModelPlatformBridge {
     },
   };
 }
+
+/**
+ * Apply a resolved model override to the current session.
+ *
+ * Resolves the string model ID to an OMP Model object via the context's
+ * modelRegistry, then calls platform.setModel() with it. Also applies
+ * thinking level if specified.
+ *
+ * @param platform - The platform adapter
+ * @param ctx - Command handler context (must have modelRegistry.getAvailable())
+ * @param actionId - The action being configured (e.g. "plan", "review") — used in notification
+ * @param resolved - The resolved model from resolveModelForAction()
+ * @returns true if model was applied, false if skipped or failed
+ */
+export async function applyModelOverride(
+  platform: Platform,
+  ctx: any,
+  actionId: string,
+  resolved: ResolvedModel,
+): Promise<boolean> {
+  // Skip if resolution fell through to the main session model (nothing to change)
+  if (resolved.source === "main") return false;
+
+  const modelId = resolved.model;
+  if (!modelId) return false;
+
+  // Apply thinking level (independent of model switch success)
+  if (resolved.thinkingLevel && platform.setThinkingLevel) {
+    platform.setThinkingLevel(resolved.thinkingLevel);
+  }
+
+  if (!platform.setModel) return false;
+
+  // Resolve string model ID to full OMP Model object via the context's model registry.
+  // OMP's setModel expects a Model object (with provider, id, api, etc.), not a string.
+  const available = ctx.modelRegistry?.getAvailable?.() as any[] | undefined;
+  if (!available) return false;
+
+  const modelObj = available.find((m: any) => {
+    if (!m?.id) return false;
+    if (modelId === m.id) return true;
+    if (modelId === `${m.provider}/${m.id}`) return true;
+    return modelId.includes("/") ? false : m.id === modelId;
+  });
+
+  if (!modelObj) return false;
+
+  // Save current model so we can restore after the agent turn completes.
+  // OMP's extension API setModel() persists to settings (calls session.setModel,
+  // not session.setModelTemporary). We must restore to avoid permanently
+  // overriding the user's default model.
+  const originalModel = ctx.model;
+
+  const applied = await platform.setModel(modelObj);
+  if (!applied) return false;
+
+  // Show persistent model override info in the footer status bar.
+  // ctx.ui.notify() is transient and gets immediately replaced by progress widgets;
+  // setStatus persists alongside them.
+  const STATUS_KEY = "supi-model";
+  const displayName = modelObj.name ?? modelObj.id ?? modelId;
+  const sourceLabel =
+    resolved.source === "action" ? `configured for ${actionId}` :
+    resolved.source === "default" ? "supipowers default" :
+    "harness role";
+  let detail = sourceLabel;
+  if (resolved.thinkingLevel) {
+    detail += ` \u00b7 ${resolved.thinkingLevel} thinking`;
+  }
+  ctx.ui?.setStatus?.(STATUS_KEY, `Model: ${displayName} (${detail})`);
+
+  // Register a one-shot agent_end hook to restore the original model
+  // and clear the status bar entry.
+  {
+    let restored = false;
+    platform.on("agent_end", async () => {
+      if (restored) return;
+      restored = true;
+      ctx.ui?.setStatus?.(STATUS_KEY, undefined);
+      if (originalModel) {
+        await platform.setModel!(originalModel);
+      }
+    });
+  }
+
+  return true;
+}

package/src/context/analyzer.ts

@@ -43,6 +43,63 @@ export function parseSystemPrompt(text: string): PromptSection[] {
   return sections;
 }
 
+// ── Per-Skill Parser ──────────────────────────────────────
+
+/** A single skill extracted from the system prompt */
+export interface ParsedSkill {
+  name: string;
+  bytes: number;
+  tokens: number;
+  content: string;
+}
+
+/** Extract individual skills from system prompt text */
+export function parseIndividualSkills(systemPrompt: string): ParsedSkill[] {
+  if (!systemPrompt) return [];
+
+  // OMP renders skills as markdown headings under "# Skills":
+  //   ## skill-name
+  //   Description text...
+  // Find the Skills section bounded by the next h1 heading or end of text.
+  const skillsSectionMatch = systemPrompt.match(
+    /^# Skills\n[\s\S]*?\n(?=##\s)/m,
+  );
+  if (!skillsSectionMatch) return [];
+
+  // Extract the region from first ## to the next # (h1) or end of text
+  const sectionStart = skillsSectionMatch.index! + skillsSectionMatch[0].length;
+  const afterSection = systemPrompt.slice(sectionStart);
+  const nextH1 = afterSection.search(/^# [^#]/m);
+  const skillsBody =
+    skillsSectionMatch[0].slice(skillsSectionMatch[0].indexOf("\n## ") + 1) +
+    (nextH1 === -1 ? afterSection : afterSection.slice(0, nextH1));
+
+  // Split on ## headings
+  const skills: ParsedSkill[] = [];
+  const headingRegex = /^## (.+)$/gm;
+  const headings: { name: string; index: number }[] = [];
+  let match;
+
+  while ((match = headingRegex.exec(skillsBody)) !== null) {
+    headings.push({ name: match[1].trim(), index: match.index });
+  }
+
+  for (let i = 0; i < headings.length; i++) {
+    const start = headings[i].index;
+    const end = i + 1 < headings.length ? headings[i + 1].index : skillsBody.length;
+    const content = skillsBody.slice(start, end).trimEnd();
+    const bytes = byteLength(content);
+    skills.push({
+      name: headings[i].name,
+      bytes,
+      tokens: estimateTokens(content),
+      content,
+    });
+  }
+
+  return skills;
+}
+
 // ── Breakdown Builder ─────────────────────────────────────
 
 /** Context usage data from OMP runtime */

package/src/context/optimizer.ts

@@ -0,0 +1,199 @@
+import type { Platform } from "../platform/types.js";
+import type { ParsedSkill, PromptSection } from "./analyzer.js";
+import { estimateTokens } from "./analyzer.js";
+
+// ── Types ───────────────────────────────────────────────────
+
+export interface TechStack {
+  languages: string[];
+  frameworks: string[];
+  tools: string[];
+  runtime: string | null;
+}
+
+/** A skill with its token cost — no classification judgment. */
+export interface SkillEntry {
+  name: string;
+  tokens: number;
+}
+
+/** A non-skill section with token cost and optional note. */
+export interface SectionEntry {
+  label: string;
+  tokens: number;
+  note: string;
+}
+
+/** Raw context report — data only, no classification. */
+export interface ContextReport {
+  totalTokens: number;
+  techStack: TechStack;
+  skills: SkillEntry[];
+  sections: SectionEntry[];
+}
+
+// ── Framework / Tool Detection Maps ─────────────────────────
+
+/** Maps package.json dependency names → detected framework or tool */
+const DEP_TO_FRAMEWORK: Record<string, string> = {
+  react: "react",
+  "react-dom": "react",
+  next: "next",
+  vue: "vue",
+  svelte: "svelte",
+  "@sveltejs/kit": "svelte",
+  express: "express",
+  fastify: "fastify",
+};
+
+const DEP_TO_TOOL: Record<string, string> = {
+  tailwindcss: "tailwind",
+  "@playwright/test": "playwright",
+  prisma: "prisma",
+  "@prisma/client": "prisma",
+  "@shadcn/ui": "shadcn",
+};
+
+// ── Tech Stack Detection ────────────────────────────────────
+
+/** Read a file via platform.exec; returns content or null on failure. */
+async function tryRead(
+  platform: Platform,
+  cwd: string,
+  filename: string,
+): Promise<string | null> {
+  const r = await platform.exec("cat", [filename], { cwd });
+  return r.code === 0 ? r.stdout : null;
+}
+
+/** Check if a file exists at `cwd/filename` via exec. */
+async function fileExists(
+  platform: Platform,
+  cwd: string,
+  filename: string,
+): Promise<boolean> {
+  const r = await platform.exec("test", ["-f", filename], { cwd });
+  return r.code === 0;
+}
+
+/**
+ * Deterministic tech-stack detection — no LLM.
+ * Inspects package.json, lockfiles, and config files.
+ */
+export async function detectTechStack(
+  platform: Platform,
+  cwd: string,
+): Promise<TechStack> {
+  const languages = new Set<string>();
+  const frameworks = new Set<string>();
+  const tools = new Set<string>();
+  let runtime: string | null = null;
+
+  // 1. package.json — deps & devDeps
+  const pkgRaw = await tryRead(platform, cwd, "package.json");
+  if (pkgRaw) {
+    try {
+      const pkg = JSON.parse(pkgRaw);
+      const allDeps: Record<string, string> = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+      };
+      for (const dep of Object.keys(allDeps)) {
+        const fw = DEP_TO_FRAMEWORK[dep];
+        if (fw) frameworks.add(fw);
+        const tl = DEP_TO_TOOL[dep];
+        if (tl) tools.add(tl);
+      }
+      if (allDeps.typescript) languages.add("typescript");
+    } catch {
+      // malformed package.json — continue with file-based detection
+    }
+  }
+
+  // 2. Lockfiles → runtime (first match wins, most-specific first)
+  if (await fileExists(platform, cwd, "bun.lock")) {
+    runtime = "bun";
+  } else if (await fileExists(platform, cwd, "package-lock.json")) {
+    runtime = "node";
+  } else if (await fileExists(platform, cwd, "pnpm-lock.yaml")) {
+    runtime = "node";
+  } else if (await fileExists(platform, cwd, "yarn.lock")) {
+    runtime = "node";
+  }
+
+  // 3. Config files → languages
+  const configChecks: [string, string][] = [
+    ["tsconfig.json", "typescript"],
+    ["Cargo.toml", "rust"],
+    ["pyproject.toml", "python"],
+    ["requirements.txt", "python"],
+    ["go.mod", "go"],
+    ["Gemfile", "ruby"],
+  ];
+  const results = await Promise.all(
+    configChecks.map(([file, lang]) =>
+      fileExists(platform, cwd, file).then((exists) =>
+        exists ? lang : null,
+      ),
+    ),
+  );
+  for (const lang of results) {
+    if (lang) languages.add(lang);
+  }
+
+  return {
+    languages: [...languages],
+    frameworks: [...frameworks],
+    tools: [...tools],
+    runtime,
+  };
+}
+
+// ── Context Report ──────────────────────────────────────────
+
+/**
+ * Build a raw context report from parsed prompt data.
+ * Gathers token costs per skill and per section, flags anomalies.
+ * Does NOT classify or recommend — that's the LLM's job.
+ */
+export function buildContextReport(
+  sections: PromptSection[],
+  skills: ParsedSkill[],
+  techStack: TechStack,
+): ContextReport {
+  const totalTokens = sections.reduce(
+    (sum, s) => sum + estimateTokens(s.content),
+    0,
+  );
+
+  const skillEntries: SkillEntry[] = skills.map((s) => ({
+    name: s.name,
+    tokens: s.tokens,
+  }));
+
+  // Annotate non-skill sections with notes for anomalies
+  const sectionEntries: SectionEntry[] = [];
+
+  const routingSections = sections.filter((s) =>
+    s.label.toLowerCase().includes("routing"),
+  );
+  const hasRoutingDupes = routingSections.length > 1;
+
+  for (const s of sections) {
+    // Skip the aggregate "Skills (N)" section — per-skill data is separate
+    if (s.label.toLowerCase().startsWith("skills")) continue;
+
+    const tokens = estimateTokens(s.content);
+    let note = "";
+
+    if (s.label.toLowerCase().includes("routing") && hasRoutingDupes) {
+      note = `Duplicate (${routingSections.length} found) — consolidate`;
+    } else if (s.label.toLowerCase().includes("memory") && tokens > 500) {
+      note = "Large — consider compressing or summarizing";
+    }
+
+    sectionEntries.push({ label: s.label, tokens, note });
+  }
+
+  return { totalTokens, techStack, skills: skillEntries, sections: sectionEntries };
+}

package/src/context-mode/compressor.ts

@@ -14,7 +14,8 @@ interface ToolResultEventResult {
 
 const BASH_HEAD_LINES = 5;
 const BASH_TAIL_LINES = 10;
-const READ_PREVIEW_LINES = 10;
+const READ_HEAD_LINES = 80;
+const READ_TAIL_LINES = 30;
 const GREP_MAX_MATCHES = 10;
 const FIND_MAX_PATHS = 20;
 
@@ -68,23 +69,25 @@ function compressBash(text: string, details: unknown): string | undefined {
   ].join("\n");
 }
 
-/** Compress read tool output */
+/** Compress read tool output — head+tail with hashline preservation */
 function compressRead(text: string, input: Record<string, unknown>): string | undefined {
-  // Scoped reads (offset/limit) are already targeted — pass through
-  if (input.offset !== undefined || input.limit !== undefined) return undefined;
+  // Scoped reads (offset/limit/sel) are already targeted — pass through
+  if (input.offset != null || input.limit != null || input.sel != null) return undefined;
 
   const lines = text.split("\n");
   const totalLines = lines.length;
-  const path = typeof input.path === "string" ? input.path : "unknown";
 
-  if (totalLines <= READ_PREVIEW_LINES) return undefined;
+  if (totalLines <= READ_HEAD_LINES + READ_TAIL_LINES) return undefined;
+
+  const head = lines.slice(0, READ_HEAD_LINES);
+  const tail = lines.slice(-READ_TAIL_LINES);
+  const omittedStart = READ_HEAD_LINES + 1;
+  const omittedEnd = totalLines - READ_TAIL_LINES;
 
-  const preview = lines.slice(0, READ_PREVIEW_LINES);
   return [
-    `File: ${path} (${totalLines} lines total)`,
-    "",
-    ...preview,
-    `[...compressed: remaining ${totalLines - READ_PREVIEW_LINES} lines omitted...]`,
+    ...head,
+    `[...${omittedEnd - omittedStart + 1} lines omitted. Use read(path, sel="L${omittedStart}-L${omittedEnd}") to view...]`,
+    ...tail,
   ].join("\n");
 }
 

package/src/context-mode/event-extractor.ts

@@ -1,7 +1,8 @@
 // src/context-mode/event-extractor.ts
+import { PRIORITY } from "./event-store.js";
 import type { EventCategory, EventPriority, TrackedEvent } from "./event-store.js";
 
-type Event = Omit<TrackedEvent, "id">;
+type Event = Omit<TrackedEvent, "id" | "dataHash">;
 
 const GIT_COMMAND_PATTERNS = [
   /^git\s+(commit|merge|rebase|checkout|switch|branch|push|pull|stash|reset|cherry-pick|tag)\b/,
@@ -39,8 +40,7 @@ function getTextContent(content: Array<{ type: string; text?: string }>): string
   return content
     .filter((c) => c.type === "text" && c.text)
     .map((c) => c.text!)
-    .join("\n")
-    .slice(0, 500); // Cap for storage
+    .join("\n");
 }
 
 /** Extract events from a tool result */
@@ -62,21 +62,29 @@ export function extractEvents(
     events.push(makeEvent(sessionId, "error", {
       toolName: event.toolName,
       content: text,
-    }, "critical", "tool_result"));
+    }, PRIORITY.critical, "tool_result"));
   }
 
   switch (event.toolName) {
     case "bash":
       extractBash(events, event, sessionId, text);
       break;
-    case "read":
+    case "read": {
+      const readPath = typeof event.input.path === "string" ? event.input.path : "";
+      if (/AGENTS\.md$/.test(readPath) || /CLAUDE\.md$/.test(readPath) || /\.omp\//.test(readPath)) {
+        events.push(makeEvent(sessionId, "rule", { path: readPath, type: "project-rule" }, PRIORITY.critical, "tool_result"));
+      }
+      if (readPath.includes("/skills/")) {
+        events.push(makeEvent(sessionId, "skill", { path: readPath }, PRIORITY.medium, "tool_result"));
+      }
       extractFile(events, event, sessionId, "read");
       break;
+    }
     case "edit":
-      extractFile(events, event, sessionId, "edit", "high");
+      extractFile(events, event, sessionId, "edit", PRIORITY.high);
       break;
     case "write":
-      extractFile(events, event, sessionId, "write", "high");
+      extractFile(events, event, sessionId, "write", PRIORITY.high);
       break;
     case "grep":
       extractFile(events, event, sessionId, "search");
@@ -87,18 +95,18 @@ export function extractEvents(
     case "todo_write":
       events.push(makeEvent(sessionId, "task", {
         input: event.input,
-      }, "high", "tool_result"));
+      }, PRIORITY.high, "tool_result"));
       break;
     default:
       if (event.toolName.startsWith("ctx_")) {
         events.push(makeEvent(sessionId, "mcp", {
           tool: event.toolName,
-        }, "low", "tool_result"));
+        }, PRIORITY.low, "tool_result"));
       } else if (event.toolName === "task" || event.toolName === "sub_agent") {
         events.push(makeEvent(sessionId, "subagent", {
           toolName: event.toolName,
           input: event.input,
-        }, "medium", "tool_result"));
+        }, PRIORITY.medium, "tool_result"));
       }
       // Unknown tools: no events
       break;
@@ -123,7 +131,7 @@ function extractBash(
     events.push(makeEvent(sessionId, "git", {
       command,
       output: text,
-    }, "high", "tool_result"));
+    }, PRIORITY.high, "tool_result"));
   }
 
   // Non-zero exit (in addition to general isError rule)
@@ -132,14 +140,28 @@ function extractBash(
       command,
       exitCode,
       output: text,
-    }, "critical", "tool_result"));
+    }, PRIORITY.critical, "tool_result"));
   }
 
   // Working directory change
   if (/\bcd\s+/.test(command)) {
     events.push(makeEvent(sessionId, "cwd", {
       command,
-    }, "low", "tool_result"));
+    }, PRIORITY.low, "tool_result"));
+  }
+
+  // Environment/version commands
+  const ENV_PATTERNS = [
+    /^(node|bun|python|ruby|go)\s+--?version/,
+    /^(npm|yarn|pnpm|pip|cargo)\s+--?version/,
+    /\bprintenv\b/,
+    /\becho\s+\$\w+/,
+  ];
+  if (ENV_PATTERNS.some((p) => p.test(command))) {
+    events.push(makeEvent(sessionId, "env", {
+      command,
+      output: text,
+    }, PRIORITY.medium, "tool_result"));
   }
 }
 
@@ -148,7 +170,7 @@ function extractFile(
   event: { input: Record<string, unknown> },
   sessionId: string,
   op: string,
-  priority: EventPriority = "medium",
+  priority: EventPriority = PRIORITY.medium,
 ): void {
   const path = typeof event.input.path === "string" ? event.input.path : "unknown";
   events.push(makeEvent(sessionId, "file", { op, path }, priority, "tool_result"));
@@ -159,11 +181,18 @@ export function extractPromptEvents(prompt: string, sessionId: string): Event[]
   const events: Event[] = [];
 
   // Always capture the prompt
-  events.push(makeEvent(sessionId, "prompt", { prompt }, "high", "before_agent_start"));
+  events.push(makeEvent(sessionId, "prompt", { prompt }, PRIORITY.high, "before_agent_start"));
 
   // Check for decision patterns
   if (DECISION_PATTERNS.some((p) => p.test(prompt))) {
-    events.push(makeEvent(sessionId, "decision", { prompt }, "high", "before_agent_start"));
+    events.push(makeEvent(sessionId, "decision", { prompt }, PRIORITY.high, "before_agent_start"));
+  }
+
+  // Detect high-level intent markers
+  const INTENT_PATTERN = /\b(build|fix|refactor|test|review|deploy|debug|plan|implement|create|delete|remove|update|add|migrate)\b/i;
+  const intentMatch = prompt.match(INTENT_PATTERN);
+  if (intentMatch) {
+    events.push(makeEvent(sessionId, "intent", { intent: intentMatch[1].toLowerCase(), prompt }, PRIORITY.low, "before_agent_start"));
   }
 
   return events;