@gannonh/kata 0.1.4 → 0.2.0

package/bin/install.js

@@ -1,9 +1,14 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const readline = require('readline');
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
+
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 // Colors
 const cyan = '\x1b[36m';
@@ -13,19 +18,20 @@ const dim = '\x1b[2m';
 const reset = '\x1b[0m';
 
 // Get version from package.json
-const pkg = require('../package.json');
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
 
 const banner = `
-${cyan}  ██╗  ██╗ █████╗ ████████╗ █████╗
-  ██║ ██╔╝██╔══██╗╚══██╔══╝██╔══██╗
-  █████╔╝ ███████║   ██║   ███████║
-  ██╔═██╗ ██╔══██║   ██║   ██╔══██║
-  ██║  ██╗██║  ██║   ██║   ██║  ██║
-  ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝${reset}
-
-  Kata ${dim}v${pkg.version}${reset}
-  A meta-prompting, context engineering and spec-driven
-  development system for Claude Code.
+${cyan}  ┌──────────────────────────────────────────────────────────┐
+  │                                                          │
+  │    ██╗  ██╗ █████╗ ████████╗ █████╗       ╔═══════╗      │
+  │    ██║ ██╔╝██╔══██╗╚══██╔══╝██╔══██╗      ║ ═╦═   ║      │
+  │    █████╔╝ ███████║   ██║   ███████║      ╠══╬══╦═╣      │
+  │    ██╔═██╗ ██╔══██║   ██║   ██╔══██║      ║  ║  ╠═╣      │
+  │    ██║  ██╗██║  ██║   ██║   ██║  ██║      ╚══╩══╩═╝      │
+  │    ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝        型           │
+  │                                                          │
+  └──────────────────────────────────────────────────────────┘${reset}
+  ${dim}v${pkg.version} · agent orchestration framework${reset}
 `;
 
 // Parse args
@@ -156,7 +162,13 @@ function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
  */
 function cleanupOrphanedFiles(claudeDir) {
   const orphanedFiles = [
-    'hooks/gsd-notify.sh',  // Removed in v1.6.x
+    'hooks/gsd-notify.sh',   // Removed in v1.6.x
+    'hooks/kata-lint.js',    // Dev-only, erroneously distributed in v1.7.x
+    'hooks/statusline.js',   // Renamed to kata-statusline.js
+  ];
+
+  const orphanedDirs = [
+    // Removed: 'commands/kata' - commands are now part of the distribution
   ];
 
   for (const relPath of orphanedFiles) {
@@ -166,6 +178,14 @@ function cleanupOrphanedFiles(claudeDir) {
       console.log(`  ${green}✓${reset} Removed orphaned ${relPath}`);
     }
   }
+
+  for (const relPath of orphanedDirs) {
+    const fullPath = path.join(claudeDir, relPath);
+    if (fs.existsSync(fullPath)) {
+      fs.rmSync(fullPath, { recursive: true });
+      console.log(`  ${green}✓${reset} Removed orphaned ${relPath}`);
+    }
+  }
 }
 
 /**
@@ -271,20 +291,6 @@ function install(isGlobal) {
   // Clean up orphaned files from previous versions
   cleanupOrphanedFiles(claudeDir);
 
-  // Create commands directory
-  const commandsDir = path.join(claudeDir, 'commands');
-  fs.mkdirSync(commandsDir, { recursive: true });
-
-  // Copy commands/kata with path replacement
-  const kataSrc = path.join(src, 'commands', 'kata');
-  const kataDest = path.join(commandsDir, 'kata');
-  copyWithPathReplacement(kataSrc, kataDest, pathPrefix);
-  if (verifyInstalled(kataDest, 'commands/kata')) {
-    console.log(`  ${green}✓${reset} Installed commands/kata`);
-  } else {
-    failures.push('commands/kata');
-  }
-
   // Copy kata skill with path replacement
   const skillSrc = path.join(src, 'kata');
   const skillDest = path.join(claudeDir, 'kata');
@@ -327,6 +333,38 @@ function install(isGlobal) {
     }
   }
 
+  // Copy skills to ~/.claude/skills (skill directories must be at root level)
+  const skillsSrc = path.join(src, 'skills');
+  if (fs.existsSync(skillsSrc)) {
+    const skillsDest = path.join(claudeDir, 'skills');
+    fs.mkdirSync(skillsDest, { recursive: true });
+
+    // Remove old Kata skills (kata-*) before copying new ones
+    if (fs.existsSync(skillsDest)) {
+      for (const dir of fs.readdirSync(skillsDest)) {
+        const dirPath = path.join(skillsDest, dir);
+        if (dir.startsWith('kata-') && fs.statSync(dirPath).isDirectory()) {
+          fs.rmSync(dirPath, { recursive: true });
+        }
+      }
+    }
+
+    // Copy each skill directory with path replacement
+    const skillEntries = fs.readdirSync(skillsSrc, { withFileTypes: true });
+    for (const entry of skillEntries) {
+      if (entry.isDirectory()) {
+        const skillSrc = path.join(skillsSrc, entry.name);
+        const skillDest = path.join(skillsDest, entry.name);
+        copyWithPathReplacement(skillSrc, skillDest, pathPrefix);
+      }
+    }
+    if (verifyInstalled(skillsDest, 'skills')) {
+      console.log(`  ${green}✓${reset} Installed skills`);
+    } else {
+      failures.push('skills');
+    }
+  }
+
   // Copy CHANGELOG.md
   const changelogSrc = path.join(src, 'CHANGELOG.md');
   const changelogDest = path.join(claudeDir, 'kata', 'CHANGELOG.md');
@@ -348,6 +386,30 @@ function install(isGlobal) {
     failures.push('VERSION');
   }
 
+  // Copy commands to ~/.claude/commands (slash commands for explicit invocation)
+  const commandsSrc = path.join(src, 'commands');
+  if (fs.existsSync(commandsSrc)) {
+    const commandsDest = path.join(claudeDir, 'commands');
+
+    // Remove old kata commands before copying new ones
+    const kataCommandsDest = path.join(commandsDest, 'kata');
+    if (fs.existsSync(kataCommandsDest)) {
+      fs.rmSync(kataCommandsDest, { recursive: true });
+    }
+
+    // Copy commands/kata directory with path replacement
+    const kataCommandsSrc = path.join(commandsSrc, 'kata');
+    if (fs.existsSync(kataCommandsSrc)) {
+      copyWithPathReplacement(kataCommandsSrc, kataCommandsDest, pathPrefix);
+    }
+
+    if (verifyInstalled(kataCommandsDest, 'commands')) {
+      console.log(`  ${green}✓${reset} Installed commands`);
+    } else {
+      failures.push('commands');
+    }
+  }
+
   // Copy hooks
   const hooksSrc = path.join(src, 'hooks');
   if (fs.existsSync(hooksSrc)) {
@@ -377,8 +439,8 @@ function install(isGlobal) {
   const settingsPath = path.join(claudeDir, 'settings.json');
   const settings = cleanupOrphanedHooks(readSettings(settingsPath));
   const statuslineCommand = isGlobal
-    ? 'node "$HOME/.claude/hooks/statusline.js"'
-    : 'node .claude/hooks/statusline.js';
+    ? 'node "$HOME/.claude/hooks/kata-statusline.js"'
+    : 'node .claude/hooks/kata-statusline.js';
   const updateCheckCommand = isGlobal
     ? 'node "$HOME/.claude/hooks/kata-check-update.js"'
     : 'node .claude/hooks/kata-check-update.js';
@@ -414,7 +476,7 @@ function install(isGlobal) {
 /**
  * Apply statusline config, then print completion message
  */
-function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline) {
+function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, isGlobal) {
   if (shouldInstallStatusline) {
     settings.statusLine = {
       type: 'command',
@@ -497,7 +559,7 @@ function promptLocation() {
     console.log(`  ${yellow}Non-interactive terminal detected, defaulting to global install${reset}\n`);
     const { settingsPath, settings, statuslineCommand } = install(true);
     handleStatusline(settings, false, (shouldInstallStatusline) => {
-      finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+      finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, true);
     });
     return;
   }
@@ -517,7 +579,7 @@ function promptLocation() {
       console.log(`\n  ${yellow}Input stream closed, defaulting to global install${reset}\n`);
       const { settingsPath, settings, statuslineCommand } = install(true);
       handleStatusline(settings, false, (shouldInstallStatusline) => {
-        finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+        finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, true);
       });
     }
   });
@@ -540,7 +602,7 @@ function promptLocation() {
     const { settingsPath, settings, statuslineCommand } = install(isGlobal);
     // Interactive mode - prompt for optional features
     handleStatusline(settings, true, (shouldInstallStatusline) => {
-      finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+      finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, isGlobal);
     });
   });
 }
@@ -556,13 +618,13 @@ if (hasGlobal && hasLocal) {
   const { settingsPath, settings, statuslineCommand } = install(true);
   // Non-interactive - respect flags
   handleStatusline(settings, false, (shouldInstallStatusline) => {
-    finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+    finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, true);
   });
 } else if (hasLocal) {
   const { settingsPath, settings, statuslineCommand } = install(false);
   // Non-interactive - respect flags
   handleStatusline(settings, false, (shouldInstallStatusline) => {
-    finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+    finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, false);
   });
 } else {
   promptLocation();

package/commands/kata/add-phase.md

@@ -1,207 +1,20 @@
 ---
-name: kata:add-phase
+name: add-phase
 description: Add phase to end of current milestone in roadmap
+version: 0.1.0
 argument-hint: <description>
+disable-model-invocation: true
 allowed-tools:
   - Read
   - Write
   - Bash
 ---
 
-<objective>
-Add a new integer phase to the end of the current milestone in the roadmap.
+## Step 1: Parse Context
 
-This command appends sequential phases to the current milestone's phase list, automatically calculating the next phase number based on existing phases.
+Phase Description: "$ARGUMENTS"
 
-Purpose: Add planned work discovered during execution that belongs at the end of current milestone.
-</objective>
+## Step 2: Invoke Skill
 
-<execution_context>
-@.planning/ROADMAP.md
-@.planning/STATE.md
-</execution_context>
-
-<process>
-
-<step name="parse_arguments">
-Parse the command arguments:
-- All arguments become the phase description
-- Example: `/kata:add-phase Add authentication` → description = "Add authentication"
-- Example: `/kata:add-phase Fix critical performance issues` → description = "Fix critical performance issues"
-
-If no arguments provided:
-
-```
-ERROR: Phase description required
-Usage: /kata:add-phase <description>
-Example: /kata:add-phase Add authentication system
-```
-
-Exit.
-</step>
-
-<step name="load_roadmap">
-Load the roadmap file:
-
-```bash
-if [ -f .planning/ROADMAP.md ]; then
-  ROADMAP=".planning/ROADMAP.md"
-else
-  echo "ERROR: No roadmap found (.planning/ROADMAP.md)"
-  exit 1
-fi
-```
-
-Read roadmap content for parsing.
-</step>
-
-<step name="find_current_milestone">
-Parse the roadmap to find the current milestone section:
-
-1. Locate the "## Current Milestone:" heading
-2. Extract milestone name and version
-3. Identify all phases under this milestone (before next "---" separator or next milestone heading)
-4. Parse existing phase numbers (including decimals if present)
-
-Example structure:
-
-```
-## Current Milestone: v1.0 Foundation
-
-### Phase 4: Focused Command System
-### Phase 5: Path Routing & Validation
-### Phase 6: Documentation & Distribution
-```
-
-</step>
-
-<step name="calculate_next_phase">
-Find the highest integer phase number in the current milestone:
-
-1. Extract all phase numbers from phase headings (### Phase N:)
-2. Filter to integer phases only (ignore decimals like 4.1, 4.2)
-3. Find the maximum integer value
-4. Add 1 to get the next phase number
-
-Example: If phases are 4, 5, 5.1, 6 → next is 7
-
-Format as two-digit: `printf "%02d" $next_phase`
-</step>
-
-<step name="generate_slug">
-Convert the phase description to a kebab-case slug:
-
-```bash
-# Example transformation:
-# "Add authentication" → "add-authentication"
-# "Fix critical performance issues" → "fix-critical-performance-issues"
-
-slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
-```
-
-Phase directory name: `{two-digit-phase}-{slug}`
-Example: `07-add-authentication`
-</step>
-
-<step name="create_phase_directory">
-Create the phase directory structure:
-
-```bash
-phase_dir=".planning/phases/${phase_num}-${slug}"
-mkdir -p "$phase_dir"
-```
-
-Confirm: "Created directory: $phase_dir"
-</step>
-
-<step name="update_roadmap">
-Add the new phase entry to the roadmap:
-
-1. Find the insertion point (after last phase in current milestone, before "---" separator)
-2. Insert new phase heading:
-
-   ```
-   ### Phase {N}: {Description}
-
-   **Goal:** [To be planned]
-   **Depends on:** Phase {N-1}
-   **Plans:** 0 plans
-
-   Plans:
-   - [ ] TBD (run /kata:plan-phase {N} to break down)
-
-   **Details:**
-   [To be added during planning]
-   ```
-
-3. Write updated roadmap back to file
-
-Preserve all other content exactly (formatting, spacing, other phases).
-</step>
-
-<step name="update_project_state">
-Update STATE.md to reflect the new phase:
-
-1. Read `.planning/STATE.md`
-2. Under "## Current Position" → "**Next Phase:**" add reference to new phase
-3. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
-   ```
-   - Phase {N} added: {description}
-   ```
-
-If "Roadmap Evolution" section doesn't exist, create it.
-</step>
-
-<step name="completion">
-Present completion summary:
-
-```
-Phase {N} added to current milestone:
-- Description: {description}
-- Directory: .planning/phases/{phase-num}-{slug}/
-- Status: Not planned yet
-
-Roadmap updated: {roadmap-path}
-Project state updated: .planning/STATE.md
-
----
-
-## ▶ Next Up
-
-**Phase {N}: {description}**
-
-`/kata:plan-phase {N}`
-
-<sub>`/clear` first → fresh context window</sub>
-
----
-
-**Also available:**
-- `/kata:add-phase <description>` — add another phase
-- Review roadmap
-
----
-```
-</step>
-
-</process>
-
-<anti_patterns>
-
-- Don't modify phases outside current milestone
-- Don't renumber existing phases
-- Don't use decimal numbering (that's /kata:insert-phase)
-- Don't create plans yet (that's /kata:plan-phase)
-- Don't commit changes (user decides when to commit)
-  </anti_patterns>
-
-<success_criteria>
-Phase addition is complete when:
-
-- [ ] Phase directory created: `.planning/phases/{NN}-{slug}/`
-- [ ] Roadmap updated with new phase entry
-- [ ] STATE.md updated with roadmap evolution note
-- [ ] New phase appears at end of current milestone
-- [ ] Next phase number calculated correctly (ignoring decimals)
-- [ ] User informed of next steps
-      </success_criteria>
+Run the following skill to add the phase:
+`Skill("kata-adding-phases")`

package/commands/kata/add-todo.md

@@ -1,182 +1,20 @@
 ---
-name: kata:add-todo
+name: add-todo
 description: Capture idea or task as todo from current conversation context
 argument-hint: [optional description]
+version: 0.1.0
+disable-model-invocation: true
 allowed-tools:
   - Read
   - Write
   - Bash
-  - Glob
 ---
 
-<objective>
-Capture an idea, task, or issue that surfaces during a Kata session as a structured todo for later work.
+## Step 1: Parse Context
 
-Enables "thought → capture → continue" flow without losing context or derailing current work.
-</objective>
+Arguments: "$ARGUMENTS"
 
-<context>
-@.planning/STATE.md
-</context>
+## Step 2: Invoke Skill
 
-<process>
-
-<step name="ensure_directory">
-```bash
-mkdir -p .planning/todos/pending .planning/todos/done
-```
-</step>
-
-<step name="check_existing_areas">
-```bash
-ls .planning/todos/pending/*.md 2>/dev/null | xargs -I {} grep "^area:" {} 2>/dev/null | cut -d' ' -f2 | sort -u
-```
-
-Note existing areas for consistency in infer_area step.
-</step>
-
-<step name="extract_content">
-**With arguments:** Use as the title/focus.
-- `/kata:add-todo Add auth token refresh` → title = "Add auth token refresh"
-
-**Without arguments:** Analyze recent conversation to extract:
-- The specific problem, idea, or task discussed
-- Relevant file paths mentioned
-- Technical details (error messages, line numbers, constraints)
-
-Formulate:
-- `title`: 3-10 word descriptive title (action verb preferred)
-- `problem`: What's wrong or why this is needed
-- `solution`: Approach hints or "TBD" if just an idea
-- `files`: Relevant paths with line numbers from conversation
-</step>
-
-<step name="infer_area">
-Infer area from file paths:
-
-| Path pattern | Area |
-|--------------|------|
-| `src/api/*`, `api/*` | `api` |
-| `src/components/*`, `src/ui/*` | `ui` |
-| `src/auth/*`, `auth/*` | `auth` |
-| `src/db/*`, `database/*` | `database` |
-| `tests/*`, `__tests__/*` | `testing` |
-| `docs/*` | `docs` |
-| `.planning/*` | `planning` |
-| `scripts/*`, `bin/*` | `tooling` |
-| No files or unclear | `general` |
-
-Use existing area from step 2 if similar match exists.
-</step>
-
-<step name="check_duplicates">
-```bash
-grep -l -i "[key words from title]" .planning/todos/pending/*.md 2>/dev/null
-```
-
-If potential duplicate found:
-1. Read the existing todo
-2. Compare scope
-
-If overlapping, use AskUserQuestion:
-- header: "Duplicate?"
-- question: "Similar todo exists: [title]. What would you like to do?"
-- options:
-  - "Skip" — keep existing todo
-  - "Replace" — update existing with new context
-  - "Add anyway" — create as separate todo
-</step>
-
-<step name="create_file">
-```bash
-timestamp=$(date "+%Y-%m-%dT%H:%M")
-date_prefix=$(date "+%Y-%m-%d")
-```
-
-Generate slug from title (lowercase, hyphens, no special chars).
-
-Write to `.planning/todos/pending/${date_prefix}-${slug}.md`:
-
-```markdown
----
-created: [timestamp]
-title: [title]
-area: [area]
-files:
-  - [file:lines]
----
-
-## Problem
-
-[problem description - enough context for future Claude to understand weeks later]
-
-## Solution
-
-[approach hints or "TBD"]
-```
-</step>
-
-<step name="update_state">
-If `.planning/STATE.md` exists:
-
-1. Count todos: `ls .planning/todos/pending/*.md 2>/dev/null | wc -l`
-2. Update "### Pending Todos" under "## Accumulated Context"
-</step>
-
-<step name="git_commit">
-Commit the todo and any updated state:
-
-```bash
-git add .planning/todos/pending/[filename]
-[ -f .planning/STATE.md ] && git add .planning/STATE.md
-git commit -m "$(cat <<'EOF'
-docs: capture todo - [title]
-
-Area: [area]
-EOF
-)"
-```
-
-Confirm: "Committed: docs: capture todo - [title]"
-</step>
-
-<step name="confirm">
-```
-Todo saved: .planning/todos/pending/[filename]
-
-  [title]
-  Area: [area]
-  Files: [count] referenced
-
----
-
-Would you like to:
-
-1. Continue with current work
-2. Add another todo
-3. View all todos (/kata:check-todos)
-```
-</step>
-
-</process>
-
-<output>
-- `.planning/todos/pending/[date]-[slug].md`
-- Updated `.planning/STATE.md` (if exists)
-</output>
-
-<anti_patterns>
-- Don't create todos for work in current plan (that's deviation rule territory)
-- Don't create elaborate solution sections — captures ideas, not plans
-- Don't block on missing information — "TBD" is fine
-</anti_patterns>
-
-<success_criteria>
-- [ ] Directory structure exists
-- [ ] Todo file created with valid frontmatter
-- [ ] Problem section has enough context for future Claude
-- [ ] No duplicates (checked and resolved)
-- [ ] Area consistent with existing todos
-- [ ] STATE.md updated if exists
-- [ ] Todo and state committed to git
-</success_criteria>
+Run the following skill:
+`Skill("kata-adding-todos")`