ctx-cc 1.0.0

package/commands/update.md

@@ -0,0 +1,117 @@
+---
+name: ctx:update
+description: Check for CTX updates and install if available
+---
+
+<objective>
+Check for CTX updates, show what's new, and install if user confirms.
+</objective>
+
+<process>
+
+<step name="get_installed_version">
+Read installed version:
+
+```bash
+cat ~/.claude/ctx/VERSION 2>/dev/null
+```
+
+If VERSION file missing, treat as version 0.0.0.
+</step>
+
+<step name="check_latest_version">
+Check npm for latest version:
+
+```bash
+npm view ctx-cc version 2>/dev/null
+```
+
+If npm check fails:
+```
+Couldn't check for updates (offline or npm unavailable).
+
+To update manually: `npx ctx-cc --force`
+```
+</step>
+
+<step name="compare_versions">
+Compare installed vs latest:
+
+**If installed == latest:**
+```
+## CTX Update
+
+**Installed:** {version}
+**Latest:** {version}
+
+You're already on the latest version.
+```
+
+**If installed < latest:**
+Continue to show changes and confirm.
+</step>
+
+<step name="show_changes">
+Fetch changelog and show what's new:
+
+```
+## CTX Update Available
+
+**Installed:** {old version}
+**Latest:** {new version}
+
+### What's New
+────────────────────────────────────────────────────────────
+
+{changelog entries between versions}
+
+────────────────────────────────────────────────────────────
+
+**Note:** The installer will replace:
+- `~/.claude/commands/ctx/`
+- `~/.claude/ctx/`
+- `~/.claude/agents/ctx-*`
+
+Your custom files are preserved.
+```
+</step>
+
+<step name="confirm_update">
+Ask user to confirm:
+
+**Options:**
+- "Yes, update now"
+- "No, cancel"
+</step>
+
+<step name="run_update">
+If confirmed:
+
+```bash
+npx ctx-cc --force
+```
+
+Clear any update cache.
+</step>
+
+<step name="complete">
+```
+╔═══════════════════════════════════════════════════════════╗
+║  CTX Updated: v{old} → v{new}                             ║
+╚═══════════════════════════════════════════════════════════╝
+
+⚠️  Restart Claude Code to pick up the new commands.
+
+View full changelog: https://github.com/jufjuf/CTX/blob/main/CHANGELOG.md
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Installed version detected
+- [ ] Latest version checked
+- [ ] Changelog shown for new versions
+- [ ] User confirmation obtained
+- [ ] Update executed successfully
+</success_criteria>

package/commands/verify.md

@@ -0,0 +1,151 @@
+---
+name: ctx:verify
+description: Three-level verification of current phase
+---
+
+<objective>
+Verify the current phase implementation using three-level verification plus anti-pattern scanning.
+</objective>
+
+<process>
+
+<step name="load_phase">
+Load current phase from `.ctx/ROADMAP.md`.
+Load verification criteria from `.ctx/phases/{phase-id}/PLAN.md`.
+
+If no phase:
+```
+No phase to verify. Run `/ctx:plan <goal>` first.
+```
+</step>
+
+<step name="three_level_verification">
+For each artifact in the phase:
+
+### Level 1: EXISTS
+```
+Question: Is the file on disk?
+Check: Glob for the file path
+Pass: File exists
+Fail: File missing
+```
+
+### Level 2: SUBSTANTIVE
+```
+Question: Is it real code, not a stub?
+Check:
+  - No "// TODO" comments in new code
+  - No empty function bodies
+  - No placeholder returns (return null, return {})
+  - No "not implemented" comments
+Pass: Real, complete implementation
+Fail: Stub or placeholder detected
+```
+
+### Level 3: WIRED
+```
+Question: Is it imported and used?
+Check:
+  - Grep for imports of the file
+  - Trace call paths from entry points
+  - Verify the code is reachable
+Pass: Connected to the application
+Fail: Orphan code (exists but unused)
+```
+</step>
+
+<step name="anti_pattern_scan">
+Scan for common anti-patterns:
+
+| Pattern | Search | Severity |
+|---------|--------|----------|
+| TODO comments | `// TODO`, `# TODO` | Warning |
+| Empty catch | `catch.*\{\s*\}` | Error |
+| Console-only errors | `console.error` without throw | Warning |
+| Placeholder returns | `return null`, `return {}` | Error |
+| Hardcoded secrets | API keys, passwords | Critical |
+| Debug code | `console.log`, `debugger` | Warning |
+</step>
+
+<step name="goal_gap_analysis">
+Check if phase goal is achieved:
+
+1. Re-read the original goal
+2. Compare against what was built
+3. Identify any gaps
+
+```
+Goal: {original goal}
+Built: {what was implemented}
+Gaps: {missing pieces, if any}
+```
+</step>
+
+<step name="generate_report">
+Write `.ctx/phases/{phase-id}/VERIFY.md`:
+
+```markdown
+# Verification Report
+
+## Phase: {name}
+## Date: {timestamp}
+
+## Three-Level Results
+
+| Artifact | Exists | Substantive | Wired | Status |
+|----------|--------|-------------|-------|--------|
+| {file1}  | ✓      | ✓           | ✓     | PASS   |
+| {file2}  | ✓      | ✓           | ✗     | FAIL   |
+
+## Anti-Pattern Scan
+
+| Pattern | Count | Files | Severity |
+|---------|-------|-------|----------|
+| TODO    | 2     | auth.ts, login.ts | Warning |
+
+## Goal Gap Analysis
+
+**Goal:** {goal}
+**Status:** {Achieved / Partially Achieved / Not Achieved}
+**Gaps:** {list or "None"}
+
+## Overall: {PASS / FAIL}
+
+{If FAIL: List what needs to be fixed}
+```
+</step>
+
+<step name="output_summary">
+Display verification summary:
+
+```
+## Verification: {phase name}
+
+**Three-Level Check:**
+  - Exists: {pass/fail count}
+  - Substantive: {pass/fail count}
+  - Wired: {pass/fail count}
+
+**Anti-Patterns:** {count} found
+**Goal Gaps:** {count or "None"}
+
+**Overall:** {PASS ✓ / FAIL ✗}
+
+{If FAIL:}
+**Action Required:**
+  - {list of fixes needed}
+
+{If PASS:}
+**Next:** Run `/ctx:phase next` or `/ctx:ship`
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] All artifacts checked at three levels
+- [ ] Anti-pattern scan completed
+- [ ] Goal gap analysis done
+- [ ] VERIFY.md written
+- [ ] Clear pass/fail determination
+</success_criteria>

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ctx-cc",
+  "version": "1.0.0",
+  "description": "CTX - Smart Context Management for Claude Code. The GSD Killer.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "context-management",
+    "workflow",
+    "development",
+    "productivity"
+  ],
+  "author": "jufjuf",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jufjuf/CTX.git"
+  },
+  "homepage": "https://github.com/jufjuf/CTX",
+  "bugs": {
+    "url": "https://github.com/jufjuf/CTX/issues"
+  },
+  "bin": {
+    "ctx-cc": "./bin/ctx.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "commands/",
+    "agents/",
+    "references/",
+    "templates/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}

package/src/install.js

@@ -0,0 +1,173 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..');
+
+const VERSION = JSON.parse(
+  fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8')
+).version;
+
+// ANSI colors
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+
+function printBanner() {
+  console.log(cyan(`
+   ██████╗████████╗██╗  ██╗
+  ██╔════╝╚══██╔══╝╚██╗██╔╝
+  ██║        ██║    ╚███╔╝
+  ██║        ██║    ██╔██╗
+  ╚██████╗   ██║   ██╔╝ ██╗
+   ╚═════╝   ╚═╝   ╚═╝  ╚═╝
+`));
+  console.log(`  ${bold('CTX')} ${dim(`v${VERSION}`)}`);
+  console.log('  Smart Context Management for Claude Code.');
+  console.log('  The GSD Killer. 12 commands, infinite power.\n');
+}
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  let count = 0;
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      count += copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+
+  return count;
+}
+
+function removeDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export async function install(options) {
+  printBanner();
+
+  // Determine target directory
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  let targetBase;
+
+  if (options.project) {
+    targetBase = path.join(process.cwd(), '.claude');
+    console.log(`  Installing for ${cyan('current project')} to ${cyan('.claude')}\n`);
+  } else {
+    targetBase = path.join(homeDir, '.claude');
+    console.log(`  Installing ${cyan('globally')} to ${cyan('~/.claude')}\n`);
+  }
+
+  // Check for existing installation
+  const commandsDir = path.join(targetBase, 'commands', 'ctx');
+  const agentsDir = targetBase === path.join(homeDir, '.claude')
+    ? path.join(targetBase, 'agents')
+    : path.join(targetBase, 'agents');
+  const ctxDir = path.join(targetBase, 'ctx');
+
+  if (fs.existsSync(commandsDir) && !options.force) {
+    const existingVersion = getExistingVersion(ctxDir);
+    if (existingVersion) {
+      console.log(yellow(`  ⚠ CTX ${existingVersion} is already installed.`));
+      console.log(`    Use ${cyan('--force')} to reinstall.\n`);
+
+      if (existingVersion === VERSION) {
+        console.log(green('  ✓ Already up to date.\n'));
+        process.exit(0);
+      }
+    }
+  }
+
+  // Clean install - remove existing
+  if (options.force || !fs.existsSync(commandsDir)) {
+    console.log('  Cleaning previous installation...');
+    removeDir(commandsDir);
+    removeDir(ctxDir);
+    // Only remove ctx-* agents, not all agents
+    if (fs.existsSync(agentsDir)) {
+      const agents = fs.readdirSync(agentsDir);
+      for (const agent of agents) {
+        if (agent.startsWith('ctx-')) {
+          fs.unlinkSync(path.join(agentsDir, agent));
+        }
+      }
+    }
+  }
+
+  // Create directories
+  fs.mkdirSync(commandsDir, { recursive: true });
+  fs.mkdirSync(ctxDir, { recursive: true });
+  fs.mkdirSync(agentsDir, { recursive: true });
+
+  // Copy commands
+  const srcCommands = path.join(packageRoot, 'commands');
+  if (fs.existsSync(srcCommands)) {
+    const count = copyDir(srcCommands, commandsDir);
+    console.log(green(`  ✓`) + ` Installed commands/ctx (${count} files)`);
+  }
+
+  // Copy agents
+  const srcAgents = path.join(packageRoot, 'agents');
+  if (fs.existsSync(srcAgents)) {
+    const agents = fs.readdirSync(srcAgents);
+    for (const agent of agents) {
+      fs.copyFileSync(
+        path.join(srcAgents, agent),
+        path.join(agentsDir, agent)
+      );
+    }
+    console.log(green(`  ✓`) + ` Installed agents (${agents.length} files)`);
+  }
+
+  // Copy references
+  const srcRefs = path.join(packageRoot, 'references');
+  const destRefs = path.join(ctxDir, 'references');
+  if (fs.existsSync(srcRefs)) {
+    const count = copyDir(srcRefs, destRefs);
+    console.log(green(`  ✓`) + ` Installed references (${count} files)`);
+  }
+
+  // Copy templates
+  const srcTemplates = path.join(packageRoot, 'templates');
+  const destTemplates = path.join(ctxDir, 'templates');
+  if (fs.existsSync(srcTemplates)) {
+    const count = copyDir(srcTemplates, destTemplates);
+    console.log(green(`  ✓`) + ` Installed templates (${count} files)`);
+  }
+
+  // Write VERSION file
+  fs.writeFileSync(path.join(ctxDir, 'VERSION'), VERSION);
+  console.log(green(`  ✓`) + ` Wrote VERSION (${VERSION})`);
+
+  // Success message
+  console.log(`\n  ${green('Done!')} Launch Claude Code and run ${cyan('/ctx:help')}.`);
+  console.log(`\n  ${dim('GitHub:')} https://github.com/jufjuf/CTX`);
+  console.log(`  ${dim('Report issues:')} https://github.com/jufjuf/CTX/issues\n`);
+}
+
+function getExistingVersion(ctxDir) {
+  const versionFile = path.join(ctxDir, 'VERSION');
+  if (fs.existsSync(versionFile)) {
+    return fs.readFileSync(versionFile, 'utf-8').trim();
+  }
+  return null;
+}