up-cc 0.1.0 → 0.1.1

package/bin/install.js

@@ -507,6 +507,49 @@ function uninstall(targetDir, runtime) {
     }
   }
 
+  // Remove UP hooks
+  const hooksDir = path.join(targetDir, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    for (const file of fs.readdirSync(hooksDir)) {
+      if (file.startsWith('up-') && file.endsWith('.js')) {
+        fs.unlinkSync(path.join(hooksDir, file));
+        removed++;
+      }
+    }
+    console.log(`  ${green}✓${reset} Removed UP hooks`);
+  }
+
+  // Clean settings.json references
+  if (runtime === 'claude') {
+    const settingsPath = path.join(targetDir, 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        let changed = false;
+
+        if (settings.statusLine && settings.statusLine.command && settings.statusLine.command.includes('up-statusline')) {
+          delete settings.statusLine;
+          changed = true;
+        }
+
+        if (settings.hooks && settings.hooks.PostToolUse) {
+          settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry => {
+            const hooks = entry.hooks || [];
+            return !hooks.some(h => h.command && h.command.includes('up-context-monitor'));
+          });
+          if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+          if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+          changed = true;
+        }
+
+        if (changed) {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+          console.log(`  ${green}✓${reset} Cleaned settings.json`);
+        }
+      } catch (e) {}
+    }
+  }
+
   if (removed === 0) {
     console.log(`  ${dim}Nothing to remove — UP is not installed here.${reset}`);
   } else {
@@ -600,12 +643,84 @@ function install(isGlobal, runtime) {
     }
   }
 
-  // 4. Write VERSION file
+  // 4. Install hooks (Claude Code only)
+  if (runtime === 'claude') {
+    const hooksSrc = path.join(packageRoot, 'hooks');
+    if (fs.existsSync(hooksSrc)) {
+      const hooksDest = path.join(targetDir, 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+
+      // Remove old UP hooks
+      if (fs.existsSync(hooksDest)) {
+        for (const file of fs.readdirSync(hooksDest)) {
+          if (file.startsWith('up-') && file.endsWith('.js')) {
+            fs.unlinkSync(path.join(hooksDest, file));
+          }
+        }
+      }
+
+      // Copy new UP hooks
+      let hookCount = 0;
+      for (const file of fs.readdirSync(hooksSrc)) {
+        if (file.endsWith('.js')) {
+          fs.copyFileSync(path.join(hooksSrc, file), path.join(hooksDest, file));
+          hookCount++;
+        }
+      }
+
+      if (hookCount > 0) {
+        console.log(`  ${green}✓${reset} Installed ${hookCount} hooks`);
+      }
+
+      // Configure statusLine and hooks in settings.json
+      const settingsPath = path.join(targetDir, 'settings.json');
+      let settings = {};
+      if (fs.existsSync(settingsPath)) {
+        try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (e) {}
+      }
+
+      const statuslineCmd = `node "${path.join(hooksDest, 'up-statusline.js')}"`;
+      const contextMonitorCmd = `node "${path.join(hooksDest, 'up-context-monitor.js')}"`;
+
+      // Set statusLine
+      settings.statusLine = { type: 'command', command: statuslineCmd };
+
+      // Set PostToolUse hook for context monitor
+      if (!settings.hooks) settings.hooks = {};
+      const postToolHooks = settings.hooks.PostToolUse || [];
+      // Remove old GSD/UP context monitor entries
+      const filtered = postToolHooks.filter(entry => {
+        const hooks = entry.hooks || [];
+        return !hooks.some(h => h.command && (h.command.includes('gsd-context-monitor') || h.command.includes('up-context-monitor')));
+      });
+      filtered.push({ hooks: [{ type: 'command', command: contextMonitorCmd }] });
+      settings.hooks.PostToolUse = filtered;
+
+      // Remove old GSD SessionStart hook if present
+      if (settings.hooks.SessionStart) {
+        settings.hooks.SessionStart = settings.hooks.SessionStart.filter(entry => {
+          const hooks = entry.hooks || [];
+          return !hooks.some(h => h.command && h.command.includes('gsd-'));
+        });
+        if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+      }
+
+      // Clean old GSD statusLine reference
+      if (settings.statusLine && settings.statusLine.command && settings.statusLine.command.includes('gsd-statusline')) {
+        settings.statusLine = { type: 'command', command: statuslineCmd };
+      }
+
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      console.log(`  ${green}✓${reset} Configured statusLine and context monitor`);
+    }
+  }
+
+  // 5. Write VERSION file
   const versionDest = path.join(upDest, 'VERSION');
   fs.writeFileSync(versionDest, VERSION);
   console.log(`  ${green}✓${reset} Wrote VERSION (${VERSION})`);
 
-  // 5. Write package.json for CommonJS mode (prevents ESM conflicts)
+  // 6. Write package.json for CommonJS mode (prevents ESM conflicts)
   if (runtime !== 'opencode') {
     const pkgDest = path.join(targetDir, 'package.json');
     if (!fs.existsSync(pkgDest)) {

package/hooks/up-context-monitor.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Context Monitor - PostToolUse hook
+// Reads context metrics from the statusline bridge file and injects
+// warnings when context usage is high.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const WARNING_THRESHOLD = 35;
+const CRITICAL_THRESHOLD = 25;
+const STALE_SECONDS = 60;
+const DEBOUNCE_CALLS = 5;
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const sessionId = data.session_id;
+
+    if (!sessionId) {
+      process.exit(0);
+    }
+
+    const tmpDir = os.tmpdir();
+    const metricsPath = path.join(tmpDir, `claude-ctx-${sessionId}.json`);
+
+    if (!fs.existsSync(metricsPath)) {
+      process.exit(0);
+    }
+
+    const metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+    const now = Math.floor(Date.now() / 1000);
+
+    if (metrics.timestamp && (now - metrics.timestamp) > STALE_SECONDS) {
+      process.exit(0);
+    }
+
+    const remaining = metrics.remaining_percentage;
+    const usedPct = metrics.used_pct;
+
+    if (remaining > WARNING_THRESHOLD) {
+      process.exit(0);
+    }
+
+    // Debounce
+    const warnPath = path.join(tmpDir, `claude-ctx-${sessionId}-warned.json`);
+    let warnData = { callsSinceWarn: 0, lastLevel: null };
+    let firstWarn = true;
+
+    if (fs.existsSync(warnPath)) {
+      try {
+        warnData = JSON.parse(fs.readFileSync(warnPath, 'utf8'));
+        firstWarn = false;
+      } catch (e) {}
+    }
+
+    warnData.callsSinceWarn = (warnData.callsSinceWarn || 0) + 1;
+
+    const isCritical = remaining <= CRITICAL_THRESHOLD;
+    const currentLevel = isCritical ? 'critical' : 'warning';
+
+    const severityEscalated = currentLevel === 'critical' && warnData.lastLevel === 'warning';
+    if (!firstWarn && warnData.callsSinceWarn < DEBOUNCE_CALLS && !severityEscalated) {
+      fs.writeFileSync(warnPath, JSON.stringify(warnData));
+      process.exit(0);
+    }
+
+    warnData.callsSinceWarn = 0;
+    warnData.lastLevel = currentLevel;
+    fs.writeFileSync(warnPath, JSON.stringify(warnData));
+
+    // Detect if UP is active (has .plano/STATE.md in working directory)
+    const cwd = data.cwd || process.cwd();
+    const isUpActive = fs.existsSync(path.join(cwd, '.plano', 'STATE.md'));
+
+    let message;
+    if (isCritical) {
+      message = isUpActive
+        ? `CONTEXT CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is nearly exhausted. Do NOT start new complex work or write handoff files -- ' +
+          'UP state is already tracked in STATE.md. Inform the user so they can run ' +
+          '/up:pausar at the next natural stopping point.'
+        : `CONTEXT CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is nearly exhausted. Inform the user that context is low and ask how they ' +
+          'want to proceed. Do NOT autonomously save state or write handoff files unless the user asks.';
+    } else {
+      message = isUpActive
+        ? `CONTEXT WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Context is getting limited. Avoid starting new complex work. If not between ' +
+          'defined plan steps, inform the user so they can prepare to pause.'
+        : `CONTEXT WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+          'Be aware that context is getting limited. Avoid unnecessary exploration or ' +
+          'starting new complex work.';
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: message
+      }
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch (e) {
+    process.exit(0);
+  }
+});

package/hooks/up-statusline.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Claude Code Statusline - UP Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to usable context)
+    const AUTO_COMPACT_BUFFER_PCT = 16.5;
+    let ctx = '';
+    if (remaining != null) {
+      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
+
+      // Write context metrics to bridge file for the context-monitor hook
+      if (session) {
+        try {
+          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
+          const bridgeData = JSON.stringify({
+            session_id: session,
+            remaining_percentage: remaining,
+            used_pct: used,
+            timestamp: Math.floor(Date.now() / 1000)
+          });
+          fs.writeFileSync(bridgePath, bridgeData);
+        } catch (e) {}
+      }
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+      if (used < 50) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 65) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 80) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude');
+    const todosDir = path.join(claudeDir, 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`\x1b[2m${model}\x1b[0m \u2502 \x1b[1m${task}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`\x1b[2m${model}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"
@@ -11,7 +11,8 @@
     "commands",
     "workflows",
     "templates",
-    "references"
+    "references",
+    "hooks"
   ],
   "keywords": [
     "claude",