supipowers 1.2.6 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {

package/skills/context-mode/SKILL.md

@@ -33,10 +33,6 @@ Instead use:
 - `ctx_execute(language: "shell", code: "find ...")` to run in sandbox
 - `ctx_batch_execute(commands, queries)` for multiple searches
 
-### Read (full-file, no limit) — BLOCKED
-Reading an entire file without a `limit` parameter is blocked.
-- If you need to **Edit** the file → re-call Read with `limit` parameter (e.g., `limit: 200`)
-- If you need to **analyze or explore** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context.
 
 ## REDIRECTED tools — use sandbox equivalents
 
@@ -46,9 +42,9 @@ For everything else, use:
 - `ctx_batch_execute(commands, queries)` — run multiple commands + search in ONE call
 - `ctx_execute(language: "shell", code: "...")` — run in sandbox, only stdout enters context
 
-### Read (for analysis)
-If you are reading a file to **Edit** it → Read with `limit` is correct (Edit needs content in context).
-If you are reading to **analyze, explore, or summarize** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context. The raw file content stays in the sandbox.
+### Read (large files)
+Reads are never blocked — they always go through OMP's native read tool so hashline anchors (`N#XX`) are preserved for the edit contract. Large file reads (>110 lines) are automatically compressed to head (80 lines) + tail (30 lines) with a `sel` hint for the omitted section.
+For analysis-only reads where hashlines aren't needed, `ctx_execute_file(path, language, code)` remains more efficient — only your printed summary enters context.
 
 ## Tool selection hierarchy
 

package/src/bootstrap.ts

@@ -17,6 +17,7 @@ import { registerModelCommand, handleModel } from "./commands/model.js";
 import { executeManagerAction } from "./mcp/manager-tool.js";
 import { registerFixPrCommand } from "./commands/fix-pr.js";
 import { registerContextCommand, handleContext } from "./commands/context.js";
+import { registerOptimizeContextCommand, handleOptimizeContext } from "./commands/optimize-context.js";
 import { registerCommitCommand, handleCommit } from "./commands/commit.js";
 import { loadConfig } from "./config/loader.js";
 import { registerContextModeHooks } from "./context-mode/hooks.js";
@@ -37,6 +38,7 @@ const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any, args?: string)
   "supi:mcp": (platform, ctx) => handleMcp(platform, ctx),
   "supi:model": (platform, ctx) => handleModel(platform, ctx),
   "supi:context": (platform, ctx) => handleContext(platform, ctx),
+  "supi:optimize-context": (platform, ctx) => handleOptimizeContext(platform, ctx),
   "supi:commit": (platform, ctx, args) => handleCommit(platform, ctx, args),
   "supi:release": (platform, ctx, args) => handleRelease(platform, ctx, args),
 };
@@ -68,6 +70,7 @@ export function bootstrap(platform: Platform): void {
   registerMcpCommand(platform);
   registerModelCommand(platform);
   registerContextCommand(platform);
+  registerOptimizeContextCommand(platform);
   registerCommitCommand(platform);
 
 

package/src/commands/optimize-context.ts

@@ -0,0 +1,202 @@
+import type { Platform, PlatformContext } from "../platform/types.js";
+import {
+  parseSystemPrompt,
+  parseIndividualSkills,
+} from "../context/analyzer.js";
+import {
+  detectTechStack,
+  buildContextReport,
+} from "../context/optimizer.js";
+import type { ContextReport } from "../context/optimizer.js";
+
+function formatTokens(n: number): string {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
+}
+
+export function handleOptimizeContext(platform: Platform, ctx: PlatformContext): void {
+  void (async () => {
+    if (!ctx.hasUI) return;
+
+    // 1. Detect tech stack
+    const techStack = await detectTechStack(platform, ctx.cwd);
+
+    // 2. Get system prompt
+    let systemPrompt = "";
+    try {
+      systemPrompt = (ctx as any).getSystemPrompt?.() ?? "";
+    } catch {
+      // getSystemPrompt not available
+    }
+
+    if (!systemPrompt) {
+      ctx.ui.notify("System prompt unavailable", "warning");
+      return;
+    }
+
+    // 3. Parse
+    const sections = parseSystemPrompt(systemPrompt);
+    const skills = parseIndividualSkills(systemPrompt);
+
+    // 4. Build raw report
+    const report = buildContextReport(sections, skills, techStack);
+
+    // 5. Show TUI
+    await showReport(platform, ctx, report);
+  })().catch((err) => {
+    ctx.ui.notify(`Optimize error: ${(err as Error).message}`, "error");
+  });
+}
+
+export function registerOptimizeContextCommand(platform: Platform): void {
+  platform.registerCommand("supi:optimize-context", {
+    description: "Analyze context usage and suggest token optimizations",
+    async handler(_args: string | undefined, ctx: any) {
+      handleOptimizeContext(platform, ctx);
+    },
+  });
+}
+
+// ── Internal ──────────────────────────────────────────────
+
+async function showReport(
+  platform: Platform,
+  ctx: PlatformContext,
+  report: ContextReport,
+): Promise<void> {
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  const lines: string[] = [
+    `Tech: ${techList || "unknown"}`,
+    `Current: ~${formatTokens(report.totalTokens)} tokens  |  Target: ~8.0K tokens`,
+    "",
+  ];
+
+  // Skills breakdown
+  if (report.skills.length === 0) {
+    lines.push("No skills detected in system prompt.");
+  } else {
+    const totalSkillTokens = report.skills.reduce((sum, s) => sum + s.tokens, 0);
+    lines.push(`Skills (${report.skills.length} loaded, ~${formatTokens(totalSkillTokens)} tok total):`);
+    lines.push("");
+
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`  ${s.name.padEnd(32)} ~${formatTokens(s.tokens)} tok`);
+    }
+  }
+
+  // Non-skill sections
+  if (report.sections.length > 0) {
+    lines.push("");
+    lines.push("Other sections:");
+    lines.push("");
+
+    for (const sec of report.sections) {
+      const tok = formatTokens(sec.tokens);
+      const note = sec.note ? `  (${sec.note})` : "";
+      lines.push(`  ${sec.label.padEnd(28)} ~${tok} tok${note}`);
+    }
+  }
+
+  const message = lines.join("\n");
+
+  // confirm() may not be available on all platforms
+  const shouldOptimize = ctx.ui.confirm
+    ? await ctx.ui.confirm("Context Optimization", message)
+    : (await ctx.ui.select("Context Optimization", [message, "▶ Optimize with AI", "Close"]))?.includes("Optimize");
+
+  if (!shouldOptimize) return;
+
+  platform.sendMessage(
+    {
+      customType: "optimize-context",
+      content: [{ type: "text", text: buildOptimizationPrompt(report) }],
+      display: "none",
+    },
+    { deliverAs: "steer", triggerTurn: true },
+  );
+}
+
+function buildOptimizationPrompt(report: ContextReport): string {
+  const lines: string[] = [];
+
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  lines.push("# Context Optimization Request");
+  lines.push("");
+  lines.push(`Current system prompt is **~${formatTokens(report.totalTokens)} tokens**. Target is **< 8K tokens**.`);
+  lines.push(`Project tech stack: **${techList || "unknown"}**`);
+  lines.push("");
+
+  // Skill inventory
+  if (report.skills.length > 0) {
+    lines.push("## Skills currently loaded");
+    lines.push("");
+    lines.push("| Skill | Tokens |");
+    lines.push("|-------|--------|");
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`| ${s.name} | ~${formatTokens(s.tokens)} |`);
+    }
+    lines.push("");
+  }
+
+  // Section inventory
+  if (report.sections.length > 0) {
+    lines.push("## Other prompt sections");
+    lines.push("");
+    for (const sec of report.sections) {
+      const note = sec.note ? ` — ${sec.note}` : "";
+      lines.push(`- **${sec.label}**: ~${formatTokens(sec.tokens)} tok${note}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## Your task");
+  lines.push("");
+  lines.push("Classify each loaded skill into one of these actions:");
+  lines.push("");
+  lines.push("| Action | Prompt cost | When to use |");
+  lines.push("|--------|-------------|-------------|");
+  lines.push("| **Keep as skill** | Full content every turn | Essential for this project, needed constantly |");
+  lines.push("| **Convert to rulebook rule** | Name + description only | Relevant but only needed on-demand (load via `rule://`) |");
+  lines.push("| **Convert to TTSR rule** | Zero | Behavioral enforcement — triggered by regex pattern in output stream |");
+  lines.push("| **Convert to slash command** | Zero | Interactive workflow the user invokes explicitly |");
+  lines.push("| **Disable** | Zero | Irrelevant to this project's tech stack |");
+  lines.push("");
+  lines.push("For each skill, consider:");
+  lines.push("1. Is it relevant to the detected tech stack? If not → **disable**.");
+  lines.push("2. Does it enforce a behavior pattern (debugging, TDD, verification)? → **TTSR** with a condition regex.");
+  lines.push("3. Is it reference material loaded for occasional lookups? → **rulebook** with a short description.");
+  lines.push("4. Is it an interactive workflow the user triggers explicitly? → **slash command**.");
+  lines.push("5. Is it essential context needed on every turn for this project? → **keep**.");
+  lines.push("");
+  lines.push("## Implementation");
+  lines.push("");
+  lines.push("After classifying, implement the changes:");
+  lines.push("");
+  lines.push("- **Rulebook**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `description: \"...\"` and condensed key content");
+  lines.push("- **TTSR**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `condition: \"regex_pattern\"`");
+  lines.push("- **Disable**: Note which skills to remove from the session configuration");
+  lines.push("- **Command**: Note which skills could become slash commands (but don't create them now)");
+  lines.push("");
+  lines.push("## Warnings");
+  lines.push("");
+  lines.push("- Do **NOT** delete files from `~/.omp/skills/` — only create project-local `.omp/rules/` files");
+  lines.push("- Rulebook and TTSR files go in `.omp/rules/` at the project root");
+  lines.push("- Preserve the original skill content's intent when condensing for rulebook rules");
+  lines.push("");
+  lines.push("Present your classification table and implementation plan first, then ask before executing.");
+
+  return lines.join("\n");
+}

package/src/commands/supi.ts

@@ -20,6 +20,7 @@ export function handleSupi(platform: Platform, ctx: PlatformContext): void {
       "/supi:doctor   — Run health checks",
       "/supi:update   — Update to latest version",
       "/supi:context  — Show context breakdown",
+      "/supi:optimize-context — Optimize context to save tokens",
     ];
 
     const status = [

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");
 }