supipowers 1.2.6 → 1.5.0

package/src/config/schema.ts

@@ -1,55 +1,120 @@
 // src/config/schema.ts
+import type { TSchema } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import type { SupipowersConfig, Profile } from "../types.js";
-
-const ConfigSchema = Type.Object({
-  version: Type.String(),
-  defaultProfile: Type.String(),
-  orchestration: Type.Object({
-    maxParallelAgents: Type.Number({ minimum: 1, maximum: 10 }),
-    maxFixRetries: Type.Number({ minimum: 0, maximum: 5 }),
-    maxNestingDepth: Type.Number({ minimum: 0, maximum: 5 }),
-    modelPreference: Type.String(),
-  }),
-  lsp: Type.Object({
-    setupGuide: Type.Boolean(),
-  }),
-  notifications: Type.Object({
-    verbosity: Type.Union([
-      Type.Literal("quiet"),
-      Type.Literal("normal"),
-      Type.Literal("verbose"),
-    ]),
-  }),
-  qa: Type.Object({
-    framework: Type.Union([Type.String(), Type.Null()]),
-    command: Type.Union([Type.String(), Type.Null()]),
-    e2e: Type.Boolean(),
-  }),
-  release: Type.Object({
-    pipeline: Type.Union([Type.String(), Type.Null()]),
-  }),
-  contextMode: Type.Object({
-    enabled: Type.Boolean(),
-    compressionThreshold: Type.Number({ minimum: 1024 }),
-    blockHttpCommands: Type.Boolean(),
-    routingInstructions: Type.Boolean(),
-    eventTracking: Type.Boolean(),
-    compaction: Type.Boolean(),
-    llmSummarization: Type.Boolean(),
-    llmThreshold: Type.Number({ minimum: 4096 }),
-  }),
-  mcp: Type.Object({
-    closeSessionsOnExit: Type.Boolean(),
-  }),
-});
+import type { SupipowersConfig } from "../types.js";
+import { QualityGatesSchema } from "../quality/schemas.js";
+
+const TAG_FORMAT_PATTERN = "^(?:(?!\\$\\{version\\}).)*\\$\\{version\\}(?:(?!\\$\\{version\\}).)*$";
+
+export const ConfigSchema = Type.Object(
+  {
+    version: Type.String(),
+    quality: Type.Object(
+      {
+        gates: QualityGatesSchema,
+      },
+      { additionalProperties: false },
+    ),
+    lsp: Type.Object(
+      {
+        setupGuide: Type.Boolean(),
+      },
+      { additionalProperties: false },
+    ),
+    qa: Type.Object(
+      {
+        framework: Type.Union([Type.String(), Type.Null()]),
+        e2e: Type.Boolean(),
+      },
+      { additionalProperties: false },
+    ),
+    release: Type.Object(
+      {
+        channels: Type.Array(Type.String()),
+        tagFormat: Type.String({ pattern: TAG_FORMAT_PATTERN }),
+        customChannels: Type.Optional(
+          Type.Record(
+            Type.String(),
+            Type.Object({
+              label: Type.String(),
+              publishCommand: Type.String(),
+              detectCommand: Type.Optional(Type.String()),
+            }),
+          ),
+        ),
+      },
+      { additionalProperties: false },
+    ),
+    contextMode: Type.Object(
+      {
+        enabled: Type.Boolean(),
+        compressionThreshold: Type.Number({ minimum: 1024 }),
+        blockHttpCommands: Type.Boolean(),
+        routingInstructions: Type.Boolean(),
+        eventTracking: Type.Boolean(),
+        compaction: Type.Boolean(),
+        llmSummarization: Type.Boolean(),
+        llmThreshold: Type.Number({ minimum: 4096 }),
+        enforceRouting: Type.Boolean(),
+      },
+      { additionalProperties: false },
+    ),
+    mcp: Type.Object(
+      {
+        closeSessionsOnExit: Type.Boolean(),
+      },
+      { additionalProperties: false },
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export interface ConfigParseError {
+  source: "global" | "project";
+  path: string;
+  message: string;
+}
+
+export interface ConfigValidationError {
+  path: string;
+  message: string;
+}
+
+export interface InspectionLoadResult {
+  mergedConfig: Record<string, unknown>;
+  effectiveConfig: SupipowersConfig | null;
+  parseErrors: ConfigParseError[];
+  validationErrors: ConfigValidationError[];
+}
+
+function normalizeErrorPath(path: string): string {
+  return path.replace(/^\//, "").replace(/\//g, ".") || "(root)";
+}
+
+function collectValidationErrors(schema: TSchema, data: unknown): ConfigValidationError[] {
+  return [...Value.Errors(schema, data)].map((error) => ({
+    path: normalizeErrorPath(error.path),
+    message: error.message,
+  }));
+}
+
+export function validateQualityGates(data: unknown): { valid: boolean; errors: string[] } {
+  const errors = collectValidationErrors(QualityGatesSchema, data).map(
+    (error) => `${error.path}: ${error.message}`,
+  );
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function collectConfigValidationErrors(data: unknown): ConfigValidationError[] {
+  return collectValidationErrors(ConfigSchema, data);
+}
 
 export function validateConfig(data: unknown): { valid: boolean; errors: string[] } {
-  const valid = Value.Check(ConfigSchema, data);
-  if (valid) return { valid: true, errors: [] };
-  const errors = [...Value.Errors(ConfigSchema, data)].map(
-    (e) => `${e.path}: ${e.message}`
+  const errors = collectConfigValidationErrors(data).map(
+    (error) => `${error.path}: ${error.message}`,
   );
-  return { valid: false, errors };
+
+  return { valid: errors.length === 0, errors };
 }

package/src/context/analyzer.ts

@@ -1,3 +1,5 @@
+import { basename } from "node:path";
+
 /** Estimate token count from text using chars/4 heuristic */
 export function estimateTokens(text: string): number {
   if (text.length === 0) return 0;
@@ -43,6 +45,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 */
@@ -190,7 +249,7 @@ function extractXmlSections(
     const content = match[0];
     const label = filePath.toLowerCase().endsWith("agents.md")
       ? "AGENTS.md"
-      : `File: ${filePath.split("/").pop() || filePath}`;
+      : `File: ${basename(filePath) || filePath}`;
     sections.push({ label, bytes: byteLength(content), content });
     markConsumed(consumed, match.index, match.index + content.length);
   }
@@ -235,7 +294,7 @@ function extractHeadingSections(
 ): void {
   const headingPatterns: Array<{ pattern: RegExp; label: string }> = [
     { pattern: /^# Memory Guidance\b/m, label: "Memory" },
-    { pattern: /^# context-mode — MANDATORY routing rules\b/m, label: "Routing rules" },
+    { pattern: /^# (?:supi-)?context-mode — MANDATORY routing rules\b/m, label: "Routing rules" },
     { pattern: /^## MCP Server Instructions\b/m, label: "MCP instructions" },
   ];
 

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/detector.ts

@@ -1,6 +1,6 @@
 // src/context-mode/detector.ts
 
-/** Which context-mode MCP tools are available in the current session */
+/** Which context-mode tools are available in the current session */
 export interface ContextModeStatus {
   available: boolean;
   tools: {
@@ -13,59 +13,21 @@ export interface ContextModeStatus {
   };
 }
 
-/** Suffixes to match against full MCP-namespaced tool names */
-const TOOL_SUFFIXES: Array<[string, keyof ContextModeStatus["tools"]]> = [
-  ["ctx_execute", "ctxExecute"],
-  ["ctx_batch_execute", "ctxBatchExecute"],
-  ["ctx_execute_file", "ctxExecuteFile"],
-  ["ctx_index", "ctxIndex"],
-  ["ctx_search", "ctxSearch"],
-  ["ctx_fetch_and_index", "ctxFetchAndIndex"],
-];
-
 /**
- * Check if a tool name matches a context-mode tool suffix.
- * Handles multiple naming conventions:
- *   - Bare names: "ctx_execute"
- *   - Claude Code MCP: "mcp__plugin_context-mode_context-mode__ctx_execute"
- *   - OMP MCP: "mcp_context_mode_ctx_execute"
- *
- * We match by checking if the tool contains a known context-mode server
- * prefix followed by the suffix, or is the bare suffix itself.
+ * Context-mode tools are native (registered by this extension), so they are
+ * always available when the extension is loaded. The interface is preserved for
+ * backward compatibility with hooks/routing consumers.
  */
-const CONTEXT_MODE_PREFIXES = [
-  "mcp__plugin_context-mode_context-mode__",  // Claude Code
-  "mcp_context_mode_",                        // OMP
-];
-
-function matchesSuffix(tool: string, suffix: string): boolean {
-  if (tool === suffix) return true;
-  for (const prefix of CONTEXT_MODE_PREFIXES) {
-    if (tool === prefix + suffix) return true;
-  }
-  return false;
-}
-
-/** Detect context-mode MCP tool availability from the active tools list */
-export function detectContextMode(activeTools: string[]): ContextModeStatus {
-  const tools: ContextModeStatus["tools"] = {
-    ctxExecute: false,
-    ctxBatchExecute: false,
-    ctxExecuteFile: false,
-    ctxIndex: false,
-    ctxSearch: false,
-    ctxFetchAndIndex: false,
+export function detectContextMode(_activeTools?: string[]): ContextModeStatus {
+  return {
+    available: true,
+    tools: {
+      ctxExecute: true,
+      ctxBatchExecute: true,
+      ctxExecuteFile: true,
+      ctxIndex: true,
+      ctxSearch: true,
+      ctxFetchAndIndex: true,
+    },
   };
-
-  for (const tool of activeTools) {
-    for (const [suffix, key] of TOOL_SUFFIXES) {
-      if (matchesSuffix(tool, suffix)) {
-        tools[key] = true;
-        break;
-      }
-    }
-  }
-
-  const available = Object.values(tools).some(Boolean);
-  return { available, tools };
-}
+}