supermind-claude 2.0.0

package/hooks/statusline-command.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+// Claude Code status line — sleek terminal aesthetic
+// Two-line display with box-drawing chars, context bar gradient, subagent tracking
+
+const { execSync } = require("child_process");
+const { readFileSync, statSync, openSync, readSync, closeSync } = require("fs");
+const { join } = require("path");
+
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => (input += chunk));
+process.stdin.on("end", () => {
+  let data = {};
+  try { data = JSON.parse(input); } catch {}
+
+  // ─── Data collection ────────────────────────────────────────────────────
+
+  const user = process.env.USER || process.env.USERNAME || "user";
+  const host = process.env.HOSTNAME || process.env.COMPUTERNAME || "";
+
+  // Working directory (normalize to Unix slashes for display)
+  let cwd = data?.workspace?.current_dir || data?.cwd || process.cwd();
+  let cwdUnix = cwd.replace(/\\/g, "/");
+  const home = (process.env.HOME || process.env.USERPROFILE || "").replace(/\\/g, "/");
+  let cwdDisplay = cwdUnix;
+  if (home && cwdDisplay.startsWith(home)) cwdDisplay = "~" + cwdDisplay.slice(home.length);
+
+  const model = data?.model?.display_name || process.env.CLAUDE_MODEL_NAME || "";
+
+  // Git branch (symbolic-ref with short hash fallback)
+  let gitBranch = "";
+  try {
+    gitBranch = execSync("git symbolic-ref --short HEAD", {
+      cwd: cwdUnix, encoding: "utf8", timeout: 2000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    try {
+      gitBranch = execSync("git rev-parse --short HEAD", {
+        cwd: cwdUnix, encoding: "utf8", timeout: 2000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+    } catch {}
+  }
+
+  // Thinking level from settings
+  let thinkingLevel = "";
+  try {
+    const sp = join(process.env.HOME || process.env.USERPROFILE, ".claude", "settings.json");
+    const s = JSON.parse(readFileSync(sp, "utf8"));
+    if (s.alwaysThinkingEnabled) thinkingLevel = s.effortLevel || "on";
+  } catch {}
+
+  // Supabase project ref from .mcp.json
+  let supabaseRef = "";
+  try {
+    const mcp = JSON.parse(readFileSync(join(cwdUnix, ".mcp.json"), "utf8"));
+    const url = mcp?.mcpServers?.supabase?.url || "";
+    const m = url.match(/project_ref=([a-z0-9]+)/);
+    if (m) supabaseRef = m[1];
+  } catch {}
+
+  // ─── Subagent detection (parse transcript tail) ─────────────────────────
+
+  let activeAgents = [];
+  try {
+    const tp = data?.transcript_path;
+    if (tp) {
+      const tpUnix = tp.replace(/\\/g, "/");
+      const stat = statSync(tpUnix);
+      const TAIL_BYTES = Math.min(stat.size, 128 * 1024); // read last 128KB
+      const buf = Buffer.alloc(TAIL_BYTES);
+      const fd = openSync(tpUnix, "r");
+      readSync(fd, buf, 0, TAIL_BYTES, stat.size - TAIL_BYTES);
+      closeSync(fd);
+      const tail = buf.toString("utf8");
+
+      // Split into lines, skip partial first line if we didn't read from start
+      const lines = tail.split("\n");
+      if (stat.size > TAIL_BYTES) lines.shift();
+
+      const agentCalls = new Map(); // tool_use id -> description
+      const completedIds = new Set();
+
+      for (const line of lines) {
+        if (!line) continue;
+        try {
+          const entry = JSON.parse(line);
+          // Find Agent tool_use in assistant messages
+          if (entry.type === "assistant" && entry.message?.content) {
+            for (const c of entry.message.content) {
+              if (c.type === "tool_use" && c.name === "Agent") {
+                agentCalls.set(c.id, c.input?.description || "agent");
+              }
+            }
+          }
+          // Find tool_result matching agent calls
+          if (entry.type === "user" && entry.message?.content) {
+            const arr = Array.isArray(entry.message.content) ? entry.message.content : [];
+            for (const c of arr) {
+              if (c.type === "tool_result" && agentCalls.has(c.tool_use_id)) {
+                completedIds.add(c.tool_use_id);
+              }
+            }
+          }
+        } catch {}
+      }
+
+      for (const [id, desc] of agentCalls) {
+        if (!completedIds.has(id)) activeAgents.push(desc);
+      }
+    }
+  } catch {}
+
+  // ─── Context window + cost ──────────────────────────────────────────────
+
+  const usedPct = data?.context_window?.used_percentage;
+  const cu = data?.context_window?.current_usage || {};
+  const usedTokens =
+    (Number(cu.input_tokens || 0) +
+      Number(cu.output_tokens || 0) +
+      Number(cu.cache_creation_input_tokens || 0) +
+      Number(cu.cache_read_input_tokens || 0)) || null;
+  const windowSize = data?.context_window?.context_window_size;
+  const cost = process.env.CLAUDE_SESSION_COST_USD;
+
+  // ─── Helpers ────────────────────────────────────────────────────────────
+
+  function fmt(n) {
+    if (n == null || n === "") return "?";
+    n = Number(n);
+    if (isNaN(n)) return "?";
+    if (n >= 1000000) return (n / 1000000).toFixed(1) + "M";
+    if (n >= 100000) return Math.floor(n / 1000) + "k";
+    if (n >= 1000) return (n / 1000).toFixed(1) + "k";
+    return String(n);
+  }
+
+  // 256-color ANSI sequences
+  const c = (n) => `\x1b[38;5;${n}m`;
+  const bg = (n) => `\x1b[48;5;${n}m`;
+  const R = "\x1b[0m";
+  const BOLD = "\x1b[1m";
+  const DIM = "\x1b[2m";
+
+  // Palette
+  const TEAL   = c(80);   // user@host
+  const ROSE   = c(204);  // model
+  const AMBER  = c(215);  // path
+  const MINT   = c(114);  // branch
+  const SKY    = c(117);  // ctx bar filled
+  const SLATE  = c(239);  // ctx bar empty / separators
+  const LILAC  = c(183);  // thinking
+  const CORAL  = c(209);  // supabase
+  const GRAY   = c(245);  // labels
+  const WHITE  = c(255);  // bright text
+  const DKGRAY = c(237);  // box chars
+
+  // ─── Progress bar (teal -> sky -> rose gradient at 75%) ─────────────────
+
+  function progressBar(pct, width = 20) {
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    // Gradient: low=teal, mid=sky, high=rose
+    let barColor = SKY;
+    if (pct > 75) barColor = c(204);
+    else if (pct > 50) barColor = c(220);
+
+    const filledStr = barColor + "\u2501".repeat(filled);
+    const emptyStr = SLATE + "\u2501".repeat(empty);
+    return filledStr + emptyStr + R;
+  }
+
+  // ─── Separators ─────────────────────────────────────────────────────────
+
+  const SEP = `${DKGRAY}  \u2502  ${R}`;
+  const DOT = `${DKGRAY} \u00b7 ${R}`;
+
+  // ─── Line 1: identity + location ────────────────────────────────────────
+
+  let line1 = `${DKGRAY}\u256d${R} `;
+  line1 += `${TEAL}${BOLD}${user}${R}${GRAY}@${R}${TEAL}${host}${R}`;
+  if (model) line1 += `${SEP}${ROSE}${model}${R}`;
+  line1 += `${SEP}${AMBER}${cwdDisplay}${R}`;
+  if (gitBranch) line1 += `${DOT}${MINT}${BOLD}${gitBranch}${R}`;
+
+  // ─── Line 2: metrics ───────────────────────────────────────────────────
+
+  let line2 = `${DKGRAY}\u2570${R} `;
+  const parts2 = [];
+
+  if (usedPct != null) {
+    const pct = Math.round(usedPct);
+    const bar = progressBar(pct);
+    parts2.push(
+      `${bar} ${WHITE}${BOLD}${pct}%${R}${GRAY} ctx${R}${DOT}${WHITE}${fmt(usedTokens)}${R}${GRAY}/${R}${WHITE}${fmt(windowSize)}${R}`,
+    );
+  }
+
+  if (thinkingLevel) {
+    const icon = thinkingLevel === "high" ? "\u25c6" : thinkingLevel === "low" ? "\u25c7" : "\u25c8";
+    parts2.push(`${LILAC}${icon} ${thinkingLevel}${R}`);
+  }
+
+  if (supabaseRef) {
+    parts2.push(`${CORAL}\u25c8 ${R}${GRAY}sb:${R}${CORAL}${supabaseRef}${R}`);
+  }
+
+  if (activeAgents.length) {
+    const CYAN = c(81);
+    const names = activeAgents
+      .map((d) => (d.length > 20 ? d.slice(0, 18) + ".." : d))
+      .join(", ");
+    const spinner =
+      ["\u280b", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"][
+        Math.floor(Date.now() / 100) % 10
+      ];
+    parts2.push(
+      `${CYAN}${spinner} ${activeAgents.length} agent${activeAgents.length > 1 ? "s" : ""}${R}${GRAY}: ${names}${R}`,
+    );
+  }
+
+  if (cost) {
+    parts2.push(`${GRAY}$${Number(cost).toFixed(2)}${R}`);
+  }
+
+  line2 += parts2.join(`${SEP}`);
+
+  // ─── Output ─────────────────────────────────────────────────────────────
+
+  if (parts2.length) {
+    process.stdout.write(`${line1}\n${line2}`);
+  } else {
+    process.stdout.write(line1);
+  }
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "supermind-claude",
+  "version": "2.0.0",
+  "description": "Complete, opinionated Claude Code setup — hooks, skills, status line, MCP servers, and living documentation",
+  "bin": {
+    "supermind-claude": "./cli/index.js",
+    "supermind": "./cli/index.js"
+  },
+  "files": [
+    "cli/",
+    "hooks/",
+    "skills/",
+    "templates/",
+    "airis/",
+    ".env.example"
+  ],
+  "keywords": ["claude", "claude-code", "ai", "developer-tools", "mcp"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/steven-3/supermind"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skills/supermind/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: supermind
+description: "Supermind — project initialization, living documentation, and configuration skills"
+---
+
+# Supermind
+
+Parent namespace for Supermind skills.
+
+## Available Commands
+
+- `/supermind-init` — Initialize a project: CLAUDE.md setup, ARCHITECTURE.md/DESIGN.md generation, health checks, and optional skill/MCP discovery
+- `/supermind-living-docs` — Manually sync ARCHITECTURE.md and DESIGN.md with the current codebase

package/skills/supermind-init/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: supermind-init
+description: "Initialize a project with Supermind. Use when starting work in a new project, when ARCHITECTURE.md is missing, or when the user wants to set up CLAUDE.md, living documentation, and project health checks. Triggers on: new project setup, missing docs, /supermind-init"
+---
+
+# Project Initialization
+
+One command to fully set up a project: creates or updates CLAUDE.md, detects the tech stack, generates living documentation (ARCHITECTURE.md + optional DESIGN.md), and optionally checks project health and discovers relevant tools.
+
+---
+
+## Phase 1: CLAUDE.md Management
+
+Section-level merging preserves your project-specific customizations while keeping infrastructure sections up to date with the latest Supermind configuration.
+
+### Section Ownership
+
+**Project-specific** (preserved during merge — user content takes priority):
+- Quick Reference
+- Commands
+- Tech Stack
+- Project Structure
+- Any custom section not listed below
+
+**Infrastructure** (replaced from template on every run):
+- Shell & Git Permissions
+- Worktree Development Workflow
+- MCP Servers
+- UI Changes
+- Living Documentation
+
+### Steps
+
+1. Read the template from `~/.claude/templates/CLAUDE.md`. If missing, tell the user to run `npx supermind-claude` first and stop.
+
+2. Check if `CLAUDE.md` exists in the project root.
+
+3. **No existing CLAUDE.md** — copy the template as-is, then proceed to step 5.
+
+4. **Existing CLAUDE.md** — perform a section-level merge:
+   a. Parse both files into sections by splitting on `## ` headings. Content before the first `## ` is the preamble.
+   b. Keep the user's preamble intact.
+   c. **Project-specific sections**: keep the user's version if it contains real content (not just placeholder comments or "Fill as project grows"). If empty or placeholder, use the template's version.
+   d. **Infrastructure sections**: always replace with the template's version.
+   e. **Custom sections** (present in the user's file but not in either ownership list): preserve them, append at end.
+   f. Output in template section order, with custom sections last.
+   g. Show the user a summary: sections preserved / updated / added / kept as custom.
+
+5. Auto-detect project context from manifest files:
+   - `package.json` — scripts for Commands, dependencies for Tech Stack
+   - `Cargo.toml` — workspace members, dependencies, build targets
+   - `go.mod` — module path, dependencies
+   - `requirements.txt` / `pyproject.toml` — Python dependencies, scripts
+   - `Gemfile` — Ruby dependencies
+   - Directory structure for Project Structure section
+
+6. Fill empty or placeholder sections only (never overwrite user content):
+   - **Commands**: from package.json scripts, Makefile targets, Cargo commands, etc.
+   - **Tech Stack**: from dependencies and config files
+   - **Project Structure**: top 2 directory levels, skipping node_modules, dist, .git, .worktrees, build, target, vendor, __pycache__
+
+7. Tell the user what was created or updated and what they should review.
+
+---
+
+## Phase 2: Living Documentation
+
+ARCHITECTURE.md uses tables-over-prose because it saves tokens — the AI reads the file index instead of scanning the entire project. This phase generates AI-optimized documentation from a deep codebase scan.
+
+### Steps
+
+8. **Determine if this is a UI project**:
+   - Auto-detect from dependencies: react, vue, svelte, angular, next, nuxt, solid, qwik, lit, stencil
+   - If not auto-detected, ask: "Does this project have a UI? (This determines whether a DESIGN.md is created)"
+
+9. **Detect scope**:
+   - If not at git root: ask "Document just this subfolder, or the entire repo?"
+   - If monorepo indicators exist (`packages/`, `apps/`, `pnpm-workspace.yaml`, workspace configs): ask "Document entire repo, or a specific subfolder?"
+   - Otherwise: scan_root = working directory
+
+10. **Check for existing ARCHITECTURE.md**:
+    - If found: ask "Keep as-is, or migrate to AI-optimized format?"
+    - Keep: skip architecture generation. Migrate: back up to `.bak`, map content into template sections.
+
+11. **Check for existing DESIGN.md** (if UI project):
+    - Same keep/migrate flow as above.
+
+12. **Generate files**:
+
+    Read the skeleton templates from this skill's directory before generating:
+    - `architecture-template.md` — section structure and table headers for ARCHITECTURE.md
+    - `design-template.md` — section structure and table headers for DESIGN.md
+
+    **Empty project** (fewer than 5 source files, excluding config, lock files, and dotfiles):
+    - Write from skeleton templates with placeholder comments.
+
+    **Existing project — Deep Scan**:
+
+    Scan exclusions: `node_modules/`, `dist/`, `build/`, `.git/`, `__pycache__/`, `target/`, `vendor/`, `.next/`, `coverage/`, gitignored paths
+
+    Scan limits:
+    - Cap File Index at 200 entries (shallower files first)
+    - Max 5 directory levels deep
+    - Priority order: File Index + Tech Stack, then API Contracts + Env Vars, then Dependencies & Data Flow
+
+    ARCHITECTURE.md scan targets:
+
+    | Scan | How | Section |
+    |------|-----|---------|
+    | Source files | Glob, read headers/exports | **File Index** |
+    | Tech stack | Read package.json, Cargo.toml, go.mod, etc. | **Tech Stack** |
+    | API routes | Find route/endpoint definitions | **API Contracts** |
+    | Env vars | Read .env.example, grep process.env / os.environ | **Environment Variables** |
+    | Import graph | Read import/require statements | **Dependencies & Data Flow** |
+    | Code patterns | Observe conventions (naming, error handling, state management) | **Key Patterns & Conventions** |
+
+    DESIGN.md scan targets (if UI project):
+
+    | Scan | How | Section |
+    |------|-----|---------|
+    | Colors | CSS custom properties, Tailwind config, theme files | **Color Tokens** |
+    | Typography | Font declarations, heading styles, text utilities | **Typography** |
+    | Spacing | CSS custom properties, Tailwind spacing config | **Spacing Scale** |
+    | Components | Component files, variants, props interfaces | **Component Patterns** |
+    | Layout | Grid systems, breakpoints, container max-widths | **Layout Conventions** |
+    | Animations | Transitions, keyframes, motion variants | **Animation Patterns** |
+
+    Leave unfilled sections with `<!-- No [X] detected -->`.
+
+13. **Commit** generated or migrated docs:
+    - New project: `git commit -m "Initialize project (CLAUDE.md, ARCHITECTURE.md[, DESIGN.md])"`
+    - Migrated: `git commit -m "Migrate living documentation to AI-optimized format"`
+
+---
+
+## Phase 3: Project Health & Discovery
+
+Different projects benefit from different tools. A database-heavy project might want a Postgres MCP, while a frontend project might want shadcn component search. This phase checks your setup and suggests relevant additions.
+
+### Steps
+
+14. Ask the user: "Would you like me to check your Supermind setup and research additional tools for this project?"
+
+15. **If yes**:
+
+    a. **Verify session hooks are firing**:
+       - Check `~/.claude/sessions/` for recent session files
+       - If no recent files found, warn that session persistence may not be configured
+
+    b. **Check Serena configuration**:
+       - Look for `.serena/` directory in the project root
+       - If missing, suggest setting up Serena for semantic code navigation
+
+    c. **Research relevant tools**:
+       - Spawn a subagent to research skills and MCPs relevant to the detected tech stack
+       - Consider the project's language, framework, database, deployment target, and testing approach
+       - Look at available MCP servers and Superpowers skills that match
+
+    d. **Present findings**:
+       - Show suggestions as a list with brief explanations of why each tool is relevant
+       - Do not auto-install anything — let the user decide
+       - Group by category: code navigation, testing, deployment, UI, database, etc.
+
+16. **If no**: skip this phase. Initialization is complete.
+
+---
+
+## Template Reference
+
+Skeleton templates are sibling files in this skill's directory:
+- `architecture-template.md` — sections and table headers for ARCHITECTURE.md
+- `design-template.md` — sections and table headers for DESIGN.md
+
+Read these before generating files to match the expected format.

package/skills/supermind-init/architecture-template.md

@@ -0,0 +1,48 @@
+# Architecture
+
+## Overview
+
+<!-- One paragraph: what the project does and its core architecture pattern -->
+
+## Tech Stack
+
+| Category | Technology | Purpose |
+|----------|-----------|---------|
+<!-- Fill as project grows -->
+
+## File Index
+
+<!-- Source files only. No generated output, lock files, node_modules, or build artifacts. -->
+<!-- Every row gets a one-line purpose description. -->
+
+| Path | Purpose |
+|------|---------|
+<!-- Fill as project grows -->
+
+## Dependencies & Data Flow
+
+### Data Flow
+
+<!-- ASCII diagram showing high-level request/data flow -->
+
+### File Dependencies
+
+| File | Depends On | Used By |
+|------|-----------|---------|
+<!-- Fill as project grows -->
+
+## API Contracts
+
+| Method | Route | Request | Response | Purpose |
+|--------|-------|---------|----------|---------|
+<!-- Fill as project grows -->
+
+## Environment Variables
+
+| Variable | Required | Purpose |
+|----------|----------|---------|
+<!-- Fill as project grows -->
+
+## Key Patterns & Conventions
+
+<!-- Document project conventions as they emerge -->

package/skills/supermind-init/design-template.md

@@ -0,0 +1,43 @@
+# Design System
+
+## Overview
+
+<!-- One paragraph: visual identity and design language summary -->
+
+## Color Tokens
+
+| Token | Value | Usage |
+|-------|-------|-------|
+<!-- Fill as project grows -->
+
+## Typography
+
+| Role | Font | Size | Weight | Line Height |
+|------|------|------|--------|-------------|
+<!-- Fill as project grows -->
+
+## Spacing Scale
+
+| Token | Value | Usage |
+|-------|-------|-------|
+<!-- Fill as project grows -->
+
+## Component Patterns
+
+<!-- Per component: variants, sizes, file path -->
+<!-- Example:
+### Button
+- Variants: primary, secondary, ghost, danger
+- Sizes: sm, md, lg
+- File: `src/components/ui/button.tsx`
+-->
+
+## Layout Conventions
+
+<!-- Grid system, breakpoints, container max-widths -->
+
+## Animation Patterns
+
+| Name | Duration | Easing | Usage |
+|------|----------|--------|-------|
+<!-- Fill as project grows -->

package/skills/supermind-living-docs/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: supermind-living-docs
+description: "Manually sync living documentation. Use when ARCHITECTURE.md or DESIGN.md need updating after code changes, when the user asks to update docs, or as a periodic check. Does not auto-trigger — this is the manual 'sync now' command."
+---
+
+# Living Documentation — Manual Sync
+
+Surgical edits preserve your existing formatting and avoid unnecessary diffs. This skill updates ARCHITECTURE.md and DESIGN.md to reflect the current state of the codebase without rewriting entire files.
+
+---
+
+## Steps
+
+1. **Read current documentation**:
+   - Read `ARCHITECTURE.md` from the project root (required — if missing, tell the user to run `/supermind-init` first)
+   - Read `DESIGN.md` from the project root (only if it exists — its presence means this is a UI project)
+
+2. **Assess recent changes**:
+   - Run `git diff --name-only` to see which files changed
+   - Run `git diff --stat` to understand the scope of changes
+   - If working on uncommitted changes, also check `git diff --name-only HEAD` and `git status`
+
+3. **Reason about what needs updating**:
+   - Files added, removed, or renamed — update **File Index**
+   - API routes changed — update **API Contracts**
+   - Dependencies added or removed — update **Tech Stack** and **Dependencies & Data Flow**
+   - Environment variables changed — update **Environment Variables**
+   - New patterns or conventions established — update **Key Patterns & Conventions**
+   - UI changes (only if DESIGN.md exists):
+     - Colors, fonts, spacing changed — update relevant design sections
+     - Components added or modified — update **Component Patterns**
+     - Layout or animation changes — update **Layout Conventions** or **Animation Patterns**
+
+4. **If nothing meaningful changed**, say so and stop. Do not make edits for the sake of making edits.
+
+5. **Make surgical edits**:
+   - Use the Edit tool to update only the sections that need changing
+   - Do NOT rewrite entire files — change only the rows, entries, or paragraphs that are affected
+   - Match the existing format and section structure exactly
+   - Keep content factual — document what IS, not what should be
+   - Always include file paths when referencing source files
+
+6. **Commit** with a descriptive message:
+   - Example: `git commit -m "Update ARCHITECTURE.md: add new API routes, update file index"`
+   - If both files were updated: `git commit -m "Update living docs: [brief description of changes]"`
+
+---
+
+## Update Rules
+
+- **Be surgical** — only update the sections that changed, never rewrite the whole doc
+- **Use the Edit tool** — do not rewrite the entire file for a small change
+- **Keep it factual** — document what IS, not what should be
+- **Include file paths** — always reference the actual source files
+- **Match the existing format** — follow the section structure already in the doc