claude-cli-advanced-starter-pack 1.8.2 → 1.8.4

package/src/utils/global-registry.js

@@ -0,0 +1,230 @@
+/**
+ * Global Project Registry
+ * Tracks all projects configured with CCASP across the system
+ * Location: ~/.claude/ccasp-registry.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import {
+  globalClaudePath,
+  getHomeDir,
+  toForwardSlashes,
+  pathsEqual,
+  getPathSegment
+} from './paths.js';
+
+/**
+ * Get the path to the global registry file
+ * @returns {string} Path to ~/.claude/ccasp-registry.json
+ */
+export function getRegistryPath() {
+  return globalClaudePath('ccasp-registry.json');
+}
+
+/**
+ * Get the global .claude directory path
+ * @returns {string} Path to ~/.claude/
+ */
+export function getGlobalClaudeDir() {
+  return join(getHomeDir(), '.claude');
+}
+
+/**
+ * Ensure the global .claude directory exists
+ */
+function ensureGlobalDir() {
+  const globalDir = getGlobalClaudeDir();
+  if (!existsSync(globalDir)) {
+    mkdirSync(globalDir, { recursive: true });
+  }
+}
+
+/**
+ * Load the global registry
+ * @returns {Object} Registry object with projects array and metadata
+ */
+export function loadRegistry() {
+  const registryPath = getRegistryPath();
+
+  if (!existsSync(registryPath)) {
+    return {
+      version: '1.0.0',
+      projects: [],
+      lastModified: null
+    };
+  }
+
+  try {
+    const content = readFileSync(registryPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`Warning: Could not parse registry file: ${err.message}`);
+    return {
+      version: '1.0.0',
+      projects: [],
+      lastModified: null
+    };
+  }
+}
+
+/**
+ * Save the global registry
+ * @param {Object} registry - Registry object to save
+ */
+export function saveRegistry(registry) {
+  ensureGlobalDir();
+  const registryPath = getRegistryPath();
+
+  registry.lastModified = new Date().toISOString();
+
+  writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf-8');
+}
+
+/**
+ * Register a project in the global registry
+ * @param {string} projectPath - Absolute path to the project
+ * @param {Object} metadata - Optional metadata (name, version, features)
+ * @returns {boolean} True if newly registered, false if already existed
+ */
+export function registerProject(projectPath, metadata = {}) {
+  const registry = loadRegistry();
+
+  // Check if already registered (using cross-platform path comparison)
+  const existingIndex = registry.projects.findIndex(
+    p => pathsEqual(p.path, projectPath)
+  );
+
+  const projectEntry = {
+    path: projectPath,
+    name: metadata.name || getPathSegment(projectPath),
+    registeredAt: new Date().toISOString(),
+    lastInitAt: new Date().toISOString(),
+    ccaspVersion: metadata.version || 'unknown',
+    features: metadata.features || []
+  };
+
+  if (existingIndex >= 0) {
+    // Update existing entry
+    registry.projects[existingIndex] = {
+      ...registry.projects[existingIndex],
+      ...projectEntry,
+      registeredAt: registry.projects[existingIndex].registeredAt // Keep original registration date
+    };
+    saveRegistry(registry);
+    return false;
+  }
+
+  // Add new entry
+  registry.projects.push(projectEntry);
+  saveRegistry(registry);
+  return true;
+}
+
+/**
+ * Unregister a project from the global registry
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {boolean} True if removed, false if not found
+ */
+export function unregisterProject(projectPath) {
+  const registry = loadRegistry();
+
+  const initialLength = registry.projects.length;
+  registry.projects = registry.projects.filter(
+    p => !pathsEqual(p.path, projectPath)
+  );
+
+  if (registry.projects.length < initialLength) {
+    saveRegistry(registry);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get all registered projects
+ * @param {Object} options - Filter options
+ * @param {boolean} options.existsOnly - Only return projects that still exist on disk
+ * @returns {Array} Array of project entries
+ */
+export function getRegisteredProjects(options = {}) {
+  const registry = loadRegistry();
+  let projects = registry.projects;
+
+  if (options.existsOnly) {
+    projects = projects.filter(p => existsSync(p.path));
+  }
+
+  return projects;
+}
+
+/**
+ * Check if a project is registered
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {boolean} True if registered
+ */
+export function isProjectRegistered(projectPath) {
+  const registry = loadRegistry();
+
+  return registry.projects.some(
+    p => pathsEqual(p.path, projectPath)
+  );
+}
+
+/**
+ * Get registry statistics
+ * @returns {Object} Stats about registered projects
+ */
+export function getRegistryStats() {
+  const registry = loadRegistry();
+  const projects = registry.projects;
+
+  let existingCount = 0;
+  let missingCount = 0;
+
+  for (const project of projects) {
+    if (existsSync(project.path)) {
+      existingCount++;
+    } else {
+      missingCount++;
+    }
+  }
+
+  return {
+    total: projects.length,
+    existing: existingCount,
+    missing: missingCount,
+    lastModified: registry.lastModified
+  };
+}
+
+/**
+ * Clean up registry by removing projects that no longer exist
+ * @returns {number} Number of projects removed
+ */
+export function cleanupRegistry() {
+  const registry = loadRegistry();
+  const initialLength = registry.projects.length;
+
+  registry.projects = registry.projects.filter(p => existsSync(p.path));
+
+  const removed = initialLength - registry.projects.length;
+  if (removed > 0) {
+    saveRegistry(registry);
+  }
+
+  return removed;
+}
+
+/**
+ * Clear the entire registry
+ */
+export function clearRegistry() {
+  const registry = {
+    version: '1.0.0',
+    projects: [],
+    lastModified: new Date().toISOString()
+  };
+  saveRegistry(registry);
+}

package/src/utils/paths.js

@@ -0,0 +1,146 @@
+/**
+ * Cross-Platform Path Utilities
+ *
+ * Centralized path handling for Windows/macOS/Linux compatibility.
+ * All path operations should use these utilities to ensure consistency.
+ */
+
+import { join, normalize, sep } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Normalize a path to use forward slashes (for comparison and storage)
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Path with forward slashes
+ */
+export function toForwardSlashes(filePath) {
+  if (!filePath) return filePath;
+  return filePath.replace(/\\/g, '/');
+}
+
+/**
+ * Normalize a path to use the platform's native separator
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Path with native separators
+ */
+export function toNativePath(filePath) {
+  if (!filePath) return filePath;
+  return filePath.replace(/[/\\]/g, sep);
+}
+
+/**
+ * Compare two paths for equality (cross-platform safe)
+ * @param {string} path1 - First path
+ * @param {string} path2 - Second path
+ * @returns {boolean} True if paths are equivalent
+ */
+export function pathsEqual(path1, path2) {
+  if (!path1 || !path2) return path1 === path2;
+  const norm1 = toForwardSlashes(path1).replace(/\/$/, '').toLowerCase();
+  const norm2 = toForwardSlashes(path2).replace(/\/$/, '').toLowerCase();
+  return norm1 === norm2;
+}
+
+/**
+ * Get the last segment of a path (cross-platform safe)
+ * @param {string} filePath - Path to extract from
+ * @returns {string} Last segment of the path
+ */
+export function getPathSegment(filePath) {
+  if (!filePath) return '';
+  return filePath.split(/[/\\]/).pop() || '';
+}
+
+/**
+ * Build a .claude-relative path string for use in config/templates
+ * Always uses forward slashes for consistency in JSON/templates
+ * @param {...string} segments - Path segments after .claude/
+ * @returns {string} Path string like ".claude/hooks/file.js"
+ */
+export function claudeRelativePath(...segments) {
+  return '.claude/' + segments.join('/');
+}
+
+/**
+ * Build an absolute path to a .claude directory item
+ * @param {string} baseDir - Project root directory
+ * @param {...string} segments - Path segments after .claude/
+ * @returns {string} Absolute path using native separators
+ */
+export function claudeAbsolutePath(baseDir, ...segments) {
+  return join(baseDir, '.claude', ...segments);
+}
+
+/**
+ * Get the user's home directory (cross-platform)
+ * @returns {string} Home directory path
+ */
+export function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+/**
+ * Build a path relative to user's home directory
+ * @param {...string} segments - Path segments after home
+ * @returns {string} Absolute path using native separators
+ */
+export function homeRelativePath(...segments) {
+  return join(getHomeDir(), ...segments);
+}
+
+/**
+ * Build a path to global .claude directory
+ * @param {...string} segments - Path segments after ~/.claude/
+ * @returns {string} Absolute path using native separators
+ */
+export function globalClaudePath(...segments) {
+  return join(getHomeDir(), '.claude', ...segments);
+}
+
+/**
+ * Check if running on Windows
+ * @returns {boolean} True if Windows
+ */
+export function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Get the appropriate command existence checker
+ * @returns {string} 'where' on Windows, 'which' on Unix
+ */
+export function getWhichCommand() {
+  return isWindows() ? 'where' : 'which';
+}
+
+/**
+ * Normalize line endings to Unix style (LF)
+ * @param {string} content - Content to normalize
+ * @returns {string} Content with Unix line endings
+ */
+export function normalizeLineEndings(content) {
+  if (!content) return content;
+  return content.replace(/\r\n/g, '\n');
+}
+
+/**
+ * Build a Node.js command that works cross-platform
+ * Uses forward slashes which Node.js handles on all platforms
+ * @param {string} scriptPath - Path to the script (relative to project root)
+ * @returns {string} Command string like "node .claude/hooks/script.js"
+ */
+export function nodeCommand(scriptPath) {
+  // Node.js handles forward slashes on all platforms
+  const normalizedPath = toForwardSlashes(scriptPath);
+  return `node ${normalizedPath}`;
+}
+
+/**
+ * Ensure a path uses consistent separators for storage/comparison
+ * Stores with forward slashes, converts to native when needed for fs operations
+ * @param {string} filePath - Path to store
+ * @returns {string} Normalized path for storage
+ */
+export function storagePath(filePath) {
+  return toForwardSlashes(filePath);
+}

package/templates/commands/create-task-list-for-issue.template.md

@@ -0,0 +1,216 @@
+---
+description: Start working on a GitHub issue by number with full workflow
+type: utility
+complexity: simple
+model: haiku
+argument-hint: <issue-number>
+allowed-tools:
+  - Bash
+  - AskUserQuestion
+  - Task
+---
+
+# /create-task-list-for-issue - Quick Issue Start
+
+**Start working on a GitHub issue by number. Confirms details, then runs full `/create-task-list` workflow.**
+
+---
+
+## USAGE
+
+```bash
+/create-task-list-for-issue 123
+/create-task-list-for-issue #45
+/create-task-list-for-issue 7
+```
+
+---
+
+## EXECUTION
+
+### Step 1: Parse Issue Number
+
+Extract issue number from `$ARGUMENTS`:
+- Strip `#` prefix if present
+- Validate it's a positive integer
+
+```
+If no issue number provided:
+  → Use AskUserQuestion: "Which issue number would you like to work on?"
+```
+
+---
+
+### Step 2: Fetch Issue Details
+
+```bash
+gh issue view [NUMBER] --json number,title,body,createdAt,labels,url
+```
+
+---
+
+### Step 3: Detect Issue Format
+
+Check if the issue body contains BOTH of these indicators of `/github-task` format:
+- `## Acceptance Criteria` OR `## Task Checklist` section
+- `## Suggested Implementation` OR `## Implementation Approach` section
+
+**Set `IS_TASK_READY`** = true if both indicators found, false otherwise.
+
+---
+
+### Step 4: Display Issue Confirmation
+
+**If IS_TASK_READY = true:**
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  Issue #[NUMBER]  ✓ Task-Ready                                ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  [Issue Title - max 50 chars]                                 ║
+║                                                               ║
+║  Created: [MM/DD/YYYY]                                        ║
+║  Labels: [label1, label2, ...]                                ║
+║  URL: [github url]                                            ║
+║                                                               ║
+║  Format: Has task checklist - will use existing tasks         ║
+║                                                               ║
+║  Tasks found:                                                 ║
+║    • [Task 1 from checklist]                                  ║
+║    • [Task 2 from checklist]                                  ║
+║    • ... ([N] total)                                          ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+**If IS_TASK_READY = false:**
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  Issue #[NUMBER]  ⚠ Needs Analysis                            ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  [Issue Title - max 50 chars]                                 ║
+║                                                               ║
+║  Created: [MM/DD/YYYY]                                        ║
+║  Labels: [label1, label2, ...]                                ║
+║  URL: [github url]                                            ║
+║                                                               ║
+║  Format: No task checklist - will generate via exploration    ║
+║                                                               ║
+║  Description preview:                                         ║
+║    [First 100 chars of issue body...]                         ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+### Step 5: Confirm and Proceed
+
+```
+header: "Start"
+question: "Start working on this issue?"
+options:
+  - label: "Y - Yes, proceed"
+    description: "Run full /create-task-list workflow"
+  - label: "V - View full details"
+    description: "Show complete issue body first"
+  - label: "N - Cancel"
+    description: "Return without starting"
+```
+
+**If user selects V (View):**
+- Run `gh issue view [NUMBER]` and display full body
+- Then re-ask the confirmation question (Y/N only)
+
+**If user selects N (Cancel):**
+- Exit command
+
+**If user selects Y (Yes):**
+- Proceed to Step 6
+
+---
+
+### Step 6: Run Full /create-task-list Workflow
+
+**If IS_TASK_READY = true:**
+
+Display:
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  📋 Starting Issue #[NUMBER] (Task-Ready)                     ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Using existing task checklist from issue                     ║
+║  Running full /create-task-list workflow for:                 ║
+║    • Codebase exploration & context                           ║
+║    • Testing configuration (Ralph loop, E2E)                  ║
+║    • Workflow setup (branch, board sync)                      ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+Run: `/create-task-list for issue #[NUMBER] --use-existing-tasks`
+
+---
+
+**If IS_TASK_READY = false:**
+
+Display:
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  📋 Starting Issue #[NUMBER] (Needs Analysis)                 ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Running full /create-task-list workflow for:                 ║
+║    • Task generation via codebase exploration                 ║
+║    • Testing configuration (Ralph loop, E2E)                  ║
+║    • Workflow setup (branch, board sync)                      ║
+║    • Option to update issue with generated tasks              ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+Run: `/create-task-list for issue #[NUMBER]`
+
+After `/create-task-list` completes and generates tasks, ask:
+
+```
+header: "Update"
+question: "Update GitHub issue with generated task list?"
+options:
+  - label: "Y - Yes, update issue"
+    description: "Add task checklist to issue body"
+  - label: "N - No, just implement"
+    description: "Keep issue as-is, start work"
+```
+
+If user selects Y:
+```bash
+# Append task checklist to issue body
+gh issue edit [NUMBER] --body "$(gh issue view [NUMBER] --json body -q .body)
+
+## Task Checklist (Auto-generated)
+
+- [ ] Task 1
+- [ ] Task 2
+..."
+```
+
+---
+
+## ERROR HANDLING
+
+| Error | Action |
+|-------|--------|
+| Issue not found | Display "Issue #[N] not found" and exit |
+| gh not authenticated | Show `gh auth login` instructions |
+| Invalid issue number | Ask user to provide valid number |
+| Network error | Show retry option |
+
+---
+
+## RELATED COMMANDS
+
+- `/menu-issues-list` - Browse all open issues with menu
+- `/create-task-list` - Create task list from any prompt
+- `/github-task-start` - Start working on issue (simpler flow)
+- `/github-update` - Sync with project board