get-shit-done-cc 1.9.0 → 1.9.2

package/commands/gsd/analyze-codebase.md

@@ -1,363 +0,0 @@
----
-name: gsd:analyze-codebase
-description: Scan existing codebase and populate .planning/intel/ with file index, conventions, and semantic entity files
-argument-hint: ""
-allowed-tools:
-  - Read
-  - Bash
-  - Glob
-  - Write
-  - Task
----
-
-<objective>
-Scan codebase to populate .planning/intel/ with file index, conventions, and semantic entity files.
-
-Works standalone (without /gsd:new-project) for brownfield codebases. Creates summary.md for context injection at session start. Generates entity files that capture file PURPOSE (what it does, why it exists), not just syntax.
-
-Output: .planning/intel/index.json, conventions.json, summary.md, entities/*.md
-</objective>
-
-<context>
-This command performs bulk codebase scanning to bootstrap the Codebase Intelligence system.
-
-**Use for:**
-- Brownfield projects before /gsd:new-project
-- Refreshing intel after major changes
-- Standalone intel without full project setup
-
-After initial scan, the PostToolUse hook (hooks/intel-index.js) maintains incremental updates.
-
-**Execution model (Step 9 - Entity Generation):**
-- Claude (executing this command) generates entity content directly
-- No embedded JavaScript - Claude reads files and writes semantic documentation
-- Task tool to spawn subagents for batch processing large codebases
-- Each subagent processes 10 files, generating Purpose-focused entity markdown
-- Users can skip Step 9 if they only want the index (faster, less context)
-</context>
-
-<process>
-
-## Step 1: Create directory structure
-
-```bash
-mkdir -p .planning/intel
-```
-
-## Step 2: Find all indexable files
-
-Use Glob tool with pattern: `**/*.{js,ts,jsx,tsx,mjs,cjs}`
-
-Exclude directories (skip any path containing):
-- node_modules
-- dist
-- build
-- .git
-- vendor
-- coverage
-- .next
-- __pycache__
-
-Filter results to remove excluded paths before processing.
-
-## Step 3: Process each file
-
-Initialize the index structure:
-```javascript
-{
-  version: 1,
-  updated: Date.now(),
-  files: {}
-}
-```
-
-For each file found:
-
-1. Read file content using Read tool
-
-2. Extract exports using these patterns:
-   - Named exports: `export\s*\{([^}]+)\}`
-   - Declaration exports: `export\s+(?:const|let|var|function\*?|async\s+function|class)\s+(\w+)`
-   - Default exports: `export\s+default\s+(?:function\s*\*?\s*|class\s+)?(\w+)?`
-   - CommonJS object: `module\.exports\s*=\s*\{([^}]+)\}`
-   - CommonJS single: `module\.exports\s*=\s*(\w+)\s*[;\n]`
-   - TypeScript: `export\s+(?:type|interface)\s+(\w+)`
-
-3. Extract imports using these patterns:
-   - ES6: `import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]`
-   - Side-effect: `import\s+['"]([^'"]+)['"]` (not preceded by 'from')
-   - CommonJS: `require\s*\(\s*['"]([^'"]+)['"]\s*\)`
-
-4. Store in index:
-   ```javascript
-   index.files[absolutePath] = {
-     exports: [],  // Array of export names
-     imports: [],  // Array of import sources
-     indexed: Date.now()
-   }
-   ```
-
-## Step 4: Detect conventions
-
-Analyze the collected index for patterns.
-
-**Naming conventions** (require 5+ exports, 70%+ match rate):
-- camelCase: `^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]+)+$` or single lowercase `^[a-z][a-z0-9]*$`
-- PascalCase: `^[A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)*$` or single `^[A-Z][a-z0-9]+$`
-- snake_case: `^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$`
-- SCREAMING_SNAKE: `^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$` or single `^[A-Z][A-Z0-9]*$`
-- Skip 'default' when counting (it's a keyword, not naming convention)
-
-**Directory patterns** (use lookup table):
-```
-components -> UI components
-hooks -> React/custom hooks
-utils, lib -> Utility functions
-services -> Service layer
-api, routes -> API endpoints
-types -> TypeScript types
-models -> Data models
-tests, __tests__, test, spec -> Test files
-controllers -> Controllers
-middleware -> Middleware
-config -> Configuration
-constants -> Constants
-pages -> Page components
-views -> View templates
-```
-
-**Suffix patterns** (require 5+ occurrences):
-```
-.test.*, .spec.* -> Test files
-.service.* -> Service layer
-.controller.* -> Controllers
-.model.* -> Data models
-.util.*, .utils.* -> Utility functions
-.helper.*, .helpers.* -> Helper functions
-.config.* -> Configuration
-.types.*, .type.* -> TypeScript types
-.hook.*, .hooks.* -> React/custom hooks
-.context.* -> React context
-.store.* -> State store
-.slice.* -> Redux slice
-.reducer.* -> Redux reducer
-.action.*, .actions.* -> Redux actions
-.api.* -> API layer
-.route.*, .routes.* -> Route definitions
-.middleware.* -> Middleware
-.schema.* -> Schema definitions
-.mock.*, .mocks.* -> Mock data
-.fixture.*, .fixtures.* -> Test fixtures
-```
-
-## Step 5: Write index.json
-
-Write to `.planning/intel/index.json`:
-```javascript
-{
-  "version": 1,
-  "updated": 1737360330000,
-  "files": {
-    "/absolute/path/to/file.js": {
-      "exports": ["functionA", "ClassB"],
-      "imports": ["react", "./utils"],
-      "indexed": 1737360330000
-    }
-  }
-}
-```
-
-## Step 6: Write conventions.json
-
-Write to `.planning/intel/conventions.json`:
-```javascript
-{
-  "version": 1,
-  "updated": 1737360330000,
-  "naming": {
-    "exports": {
-      "dominant": "camelCase",
-      "count": 42,
-      "percentage": 85
-    }
-  },
-  "directories": {
-    "components": { "purpose": "UI components", "files": 15 },
-    "hooks": { "purpose": "React/custom hooks", "files": 8 }
-  },
-  "suffixes": {
-    ".test.js": { "purpose": "Test files", "count": 12 }
-  }
-}
-```
-
-## Step 7: Generate summary.md
-
-Write to `.planning/intel/summary.md`:
-
-```markdown
-# Codebase Intelligence Summary
-
-Last updated: [ISO timestamp]
-Indexed files: [N]
-
-## Naming Conventions
-
-- Export naming: [case] ([percentage]% of [count] exports)
-
-## Key Directories
-
-- `[dir]/`: [purpose] ([N] files)
-- ... (top 5)
-
-## File Patterns
-
-- `*[suffix]`: [purpose] ([count] files)
-- ... (top 3)
-
-Total exports: [N]
-```
-
-Target: < 500 tokens. Keep concise for context injection.
-
-## Step 8: Report completion
-
-Display summary statistics:
-
-```
-Codebase Analysis Complete
-
-Files indexed: [N]
-Exports found: [N]
-Imports found: [N]
-
-Conventions detected:
-- Naming: [dominant case] ([percentage]%)
-- Directories: [list]
-- Patterns: [list]
-
-Files created:
-- .planning/intel/index.json
-- .planning/intel/conventions.json
-- .planning/intel/summary.md
-```
-
-## Step 9: Generate semantic entities (optional)
-
-Generate entity files that capture semantic understanding of key files. These provide PURPOSE, not just syntax.
-
-**Skip this step if:** User only wants the index, or codebase has < 10 files.
-
-### 9.1 Create entities directory
-
-```bash
-mkdir -p .planning/intel/entities
-```
-
-### 9.2 Select files for entity generation
-
-Select up to 50 files based on these criteria (in priority order):
-
-1. **High-export files:** 3+ exports (likely core modules)
-2. **Hub files:** Referenced by 5+ other files (via imports analysis)
-3. **Key directories:** Entry points (index.js, main.js, app.js), config files
-4. **Structural files:** Files matching convention patterns (services, controllers, models)
-
-From the index.json, identify candidates and limit to 50 files maximum per run.
-
-### 9.3 Generate entities via Task tool batching
-
-Process selected files in **batches of 10** using the Task tool to spawn subagents.
-
-For each batch, spawn a Task with this instruction:
-
-```
-Generate semantic entity files for these source files:
-[list of 10 absolute file paths]
-
-For each file:
-1. Read the file content
-2. Write an entity markdown file to .planning/intel/entities/
-
-Entity filename convention (slug):
-- Take the relative path from project root
-- Replace / with --
-- Replace . with -
-- Example: src/utils/auth.js -> src--utils--auth-js.md
-
-Entity template:
----
-source: [absolute path]
-indexed: [ISO timestamp]
----
-
-# [filename]
-
-## Purpose
-
-[1-2 sentences: What does this file DO? Why does it exist? What problem does it solve?]
-
-## Exports
-
-| Name | Type | Purpose |
-|------|------|---------|
-| [export] | [function/class/const/type] | [what it does] |
-
-## Dependencies
-
-| Import | Purpose |
-|--------|---------|
-| [import source] | [why this file needs it] |
-
-## Used By
-
-[If this file is imported by others in the codebase, list the key consumers and why they use it. Otherwise: "Entry point" or "Utility - used across codebase"]
-
----
-
-Focus on PURPOSE and semantic understanding, not just listing syntax.
-```
-
-### 9.4 Verify entity generation
-
-After all batches complete:
-
-```bash
-ls .planning/intel/entities/*.md | wc -l
-```
-
-Confirm entity count matches expected file count.
-
-### 9.5 Report entity statistics
-
-```
-Entity Generation Complete
-
-Entity files created: [N]
-Location: .planning/intel/entities/
-
-Batches processed: [N]
-Files per batch: 10
-
-Next: Intel hooks will continue incremental learning as you code.
-```
-
-</process>
-
-<output>
-- .planning/intel/index.json - File index with exports and imports
-- .planning/intel/conventions.json - Detected naming and structural patterns
-- .planning/intel/summary.md - Concise summary for context injection
-- .planning/intel/entities/*.md - Semantic entity files (optional, Step 9)
-</output>
-
-<success_criteria>
-- [ ] .planning/intel/ directory created
-- [ ] All JS/TS files scanned (excluding node_modules, dist, build, .git, vendor, coverage)
-- [ ] index.json populated with exports and imports for each file
-- [ ] conventions.json has detected patterns (naming, directories, suffixes)
-- [ ] summary.md is concise (< 500 tokens)
-- [ ] Statistics reported to user
-- [ ] Entity files generated for key files (if Step 9 executed)
-- [ ] Entity files contain Purpose section with semantic understanding
-</success_criteria>

package/commands/gsd/query-intel.md

@@ -1,128 +0,0 @@
----
-name: gsd:query-intel
-description: Query codebase intelligence graph for dependencies and hotspots
-argument-hint: "<dependents|hotspots> [file-path]"
-allowed-tools:
-  - Bash
----
-
-<objective>
-Query the codebase intelligence graph database for relationship information.
-
-**Query types:**
-- `dependents <file>` — What files depend on this file? (blast radius)
-- `hotspots` — Which files have the most dependents? (change carefully)
-
-Output: Formatted query results from graph.db
-</objective>
-
-<context>
-This command exposes the graph query capabilities built by Phase 4 (Semantic Intelligence).
-
-**Use for:**
-- Checking blast radius before refactoring a core file
-- Identifying high-impact files that need careful changes
-- Understanding dependency relationships in the codebase
-
-**Requires:** `.planning/intel/graph.db` (created by `/gsd:analyze-codebase` with entity generation)
-
-If graph.db doesn't exist, the command will return an error suggesting to run analyze-codebase first.
-</context>
-
-<process>
-
-## Step 1: Parse arguments
-
-Extract query type and optional file path from arguments.
-
-**Arguments:** $ARGUMENTS
-
-**Expected formats:**
-- `dependents src/lib/db.ts` — query what depends on this file
-- `hotspots` — query most-depended-on files
-- `hotspots 10` — query top 10 hotspots (default: 5)
-
-## Step 2: Convert file path to entity ID
-
-For `dependents` queries, convert the file path to entity ID format:
-- `src/lib/db.ts` → `src-lib-db`
-- Replace `/` with `-`, remove extension
-
-```bash
-# Example conversion
-FILE_PATH="src/lib/db.ts"
-ENTITY_ID=$(echo "$FILE_PATH" | sed 's/\.[^.]*$//' | tr '/' '-')
-```
-
-## Step 3: Execute query
-
-Run the appropriate query against the graph database:
-
-**For dependents:**
-```bash
-echo '{"action":"query","type":"dependents","target":"'$ENTITY_ID'","limit":20}' | node hooks/gsd-intel-index.js
-```
-
-**For hotspots:**
-```bash
-echo '{"action":"query","type":"hotspots","limit":5}' | node hooks/gsd-intel-index.js
-```
-
-## Step 4: Format and present results
-
-Parse the JSON response and present in readable format.
-
-**For dependents:**
-```
-## Files that depend on {file-path}
-
-Found {count} dependents:
-
-1. src/api/users.ts
-2. src/api/auth.ts
-3. src/services/payment.ts
-...
-
-**Blast radius:** {count} files would be affected by changes.
-```
-
-**For hotspots:**
-```
-## Dependency Hotspots
-
-These files have the most dependents — change carefully:
-
-| Rank | File | Dependents |
-|------|------|------------|
-| 1 | src/lib/db.ts | 42 |
-| 2 | src/types/user.ts | 35 |
-| 3 | src/utils/format.ts | 28 |
-```
-
-## Step 5: Handle errors
-
-**If graph.db doesn't exist:**
-```
-No graph database found at .planning/intel/graph.db
-
-Run /gsd:analyze-codebase first to build the dependency graph.
-```
-
-**If entity not found:**
-```
-No entity found for: {file-path}
-
-The file may not be indexed yet. Try:
-- /gsd:analyze-codebase to rebuild the index
-- Check the file path is correct
-```
-
-</process>
-
-<success_criteria>
-- [ ] Query type parsed from arguments
-- [ ] File path converted to entity ID (for dependents)
-- [ ] Query executed against graph.db
-- [ ] Results formatted in readable markdown
-- [ ] Errors handled gracefully with helpful messages
-</success_criteria>

package/get-shit-done/templates/entity.md

@@ -1,173 +0,0 @@
-# Entity Template
-
-Template for `.planning/codebase/{entity-slug}.md` - file-level intelligence documentation.
-
----
-
-## File Template
-
-```markdown
----
-path: {path}
-type: {type}
-updated: {updated}
-status: {status}
----
-
-# {filename}
-
-## Purpose
-
-{purpose}
-
-## Exports
-
-{exports}
-
-## Dependencies
-
-{dependencies}
-
-## Used By
-
-{used_by}
-
-## Notes
-
-{notes}
-```
-
----
-
-## Field Reference
-
-### Frontmatter
-
-| Field | Values | Description |
-|-------|--------|-------------|
-| `path` | Absolute path | Full path to the file |
-| `type` | module, component, util, config, test, api, hook | Primary classification |
-| `updated` | YYYY-MM-DD | Last time this entity was updated |
-| `status` | active, deprecated, stub | Current state |
-
-### Sections
-
-**Purpose** (required)
-1-3 sentences covering:
-- What this file does
-- Why it exists
-- Who/what uses it (high-level)
-
-**Exports** (required for modules with exports)
-List each export with signature and description:
-```markdown
-- `functionName(arg: Type): ReturnType` - What it does
-- `ClassName` - What it represents
-- `CONSTANT_NAME` - What value it holds
-```
-
-For files without exports (config, tests), write "None" or describe what the file defines.
-
-**Dependencies** (required)
-Internal dependencies use wiki-links (slugified paths):
-```markdown
-- [[src-lib-db]] - Database client
-- [[src-types-user]] - User type definitions
-```
-
-External dependencies use plain text:
-```markdown
-- react - Component framework
-- jose - JWT handling
-```
-
-**Used By** (grows over time)
-Files that import this one, using wiki-links:
-```markdown
-- [[src-app-api-auth-route]]
-- [[src-components-dashboard]]
-```
-
-Initially may be empty or incomplete. Updated as Claude encounters imports.
-
-**Notes** (optional)
-Patterns, gotchas, or context:
-```markdown
-- Uses singleton pattern for connection pooling
-- WARNING: Must call `init()` before any other method
-- Related: See [[src-lib-cache]] for caching layer
-```
-
----
-
-## Slug Convention
-
-Entity slugs are derived from file paths:
-- `src/lib/db.ts` becomes `src-lib-db`
-- `src/app/api/auth/route.ts` becomes `src-app-api-auth-route`
-
-Rule: Replace `/` and `.` with `-`, drop file extension.
-
----
-
-## Example
-
-```markdown
----
-path: /project/src/lib/auth.ts
-type: util
-updated: 2025-01-15
-status: active
----
-
-# auth.ts
-
-## Purpose
-
-JWT token management using jose library. Handles token creation, verification, and refresh rotation. Used by all protected API routes via middleware.
-
-## Exports
-
-- `createAccessToken(userId: string): Promise<string>` - Creates 15-min access token
-- `createRefreshToken(userId: string): Promise<string>` - Creates 7-day refresh token
-- `verifyToken(token: string): Promise<TokenPayload>` - Validates and decodes token
-- `rotateRefresh(oldToken: string): Promise<TokenPair>` - Issues new token pair
-
-## Dependencies
-
-- [[src-lib-db]] - Stores refresh tokens for revocation
-- [[src-types-auth]] - TokenPayload, TokenPair types
-- jose - JWT signing and verification
-- bcrypt - Password hashing
-
-## Used By
-
-- [[src-middleware]]
-- [[src-app-api-auth-login-route]]
-- [[src-app-api-auth-logout-route]]
-- [[src-app-api-auth-refresh-route]]
-
-## Notes
-
-- Access tokens are stateless; refresh tokens stored in DB for revocation
-- Uses RS256 algorithm with keys from environment
-- WARNING: Never log token values, even in debug mode
-```
-
----
-
-## Guidelines
-
-**When to create/update:**
-- After modifying a file during plan execution
-- When encountering a file that lacks documentation
-- When relationships change (new imports, exports)
-
-**Minimal viable entity:**
-At minimum, an entity needs frontmatter + Purpose. Other sections can be "TBD" if unknown.
-
-**Accuracy over completeness:**
-Better to have partial accurate info than complete guesses. Mark unknowns explicitly.
-
-**Link discovery:**
-The hook that processes entities extracts all `[[wiki-links]]` to build the relationship graph. Ensure links use correct slug format.