claude-all-hands 1.0.1 → 1.0.2

package/bin/cli.js

@@ -4856,9 +4856,79 @@ var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
 // src/commands/init.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5, writeFileSync, mkdirSync, copyFileSync, renameSync } from "fs";
-import { join as join2, dirname as dirname4, resolve as resolve6 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
+import { copyFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, renameSync, writeFileSync } from "fs";
+import { dirname as dirname4, join as join2, resolve as resolve6 } from "path";
+import * as readline from "readline";
+
+// src/lib/git.ts
+import { execSync, spawnSync } from "child_process";
+function git(args, cwd) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return {
+    success: result.status === 0,
+    stdout: result.stdout?.trim() || "",
+    stderr: result.stderr?.trim() || ""
+  };
+}
+function getCurrentBranch(repoPath) {
+  const result = git(["rev-parse", "--abbrev-ref", "HEAD"], repoPath);
+  return result.success ? result.stdout : "";
+}
+function getRepoName(repoPath) {
+  const result = git(["remote", "get-url", "origin"], repoPath);
+  if (result.success) {
+    let name = result.stdout.split("/").pop() || "";
+    if (name.endsWith(".git")) {
+      name = name.slice(0, -4);
+    }
+    return name;
+  }
+  return repoPath.split("/").pop() || "unknown";
+}
+function getStagedFiles(repoPath) {
+  const result = git(["diff", "--cached", "--name-only"], repoPath);
+  if (!result.success || !result.stdout) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(result.stdout.split("\n").filter(Boolean));
+}
+function isGitRepo(path2) {
+  const result = git(["rev-parse", "--git-dir"], path2);
+  return result.success;
+}
+function ghCli(args, cwd) {
+  const result = spawnSync("gh", args, {
+    cwd,
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return {
+    success: result.status === 0,
+    stdout: result.stdout?.trim() || "",
+    stderr: result.stderr?.trim() || ""
+  };
+}
+function checkGitInstalled() {
+  try {
+    execSync("git --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkGhInstalled() {
+  try {
+    execSync("gh --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/manifest.ts
 import { readFileSync as readFileSync4, existsSync, readdirSync as readdirSync2 } from "fs";
@@ -6501,75 +6571,6 @@ function isIgnored(path2, patterns) {
   return patterns.some((pattern) => minimatch(path2, pattern, { dot: true }));
 }
 
-// src/lib/git.ts
-import { execSync, spawnSync } from "child_process";
-function git(args, cwd) {
-  const result = spawnSync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    maxBuffer: 10 * 1024 * 1024
-  });
-  return {
-    success: result.status === 0,
-    stdout: result.stdout?.trim() || "",
-    stderr: result.stderr?.trim() || ""
-  };
-}
-function getCurrentBranch(repoPath) {
-  const result = git(["rev-parse", "--abbrev-ref", "HEAD"], repoPath);
-  return result.success ? result.stdout : "";
-}
-function getRepoName(repoPath) {
-  const result = git(["remote", "get-url", "origin"], repoPath);
-  if (result.success) {
-    let name = result.stdout.split("/").pop() || "";
-    if (name.endsWith(".git")) {
-      name = name.slice(0, -4);
-    }
-    return name;
-  }
-  return repoPath.split("/").pop() || "unknown";
-}
-function getStagedFiles(repoPath) {
-  const result = git(["diff", "--cached", "--name-only"], repoPath);
-  if (!result.success || !result.stdout) {
-    return /* @__PURE__ */ new Set();
-  }
-  return new Set(result.stdout.split("\n").filter(Boolean));
-}
-function isGitRepo(path2) {
-  const result = git(["rev-parse", "--git-dir"], path2);
-  return result.success;
-}
-function ghCli(args, cwd) {
-  const result = spawnSync("gh", args, {
-    cwd,
-    encoding: "utf-8",
-    maxBuffer: 10 * 1024 * 1024
-  });
-  return {
-    success: result.status === 0,
-    stdout: result.stdout?.trim() || "",
-    stderr: result.stderr?.trim() || ""
-  };
-}
-function checkGitInstalled() {
-  try {
-    execSync("git --version", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function checkGhInstalled() {
-  try {
-    execSync("gh --version", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/lib/paths.ts
 import { existsSync as existsSync2 } from "fs";
 import { dirname as dirname3, resolve as resolve5 } from "path";
@@ -6599,7 +6600,6 @@ function getAllhandsRoot() {
 }
 
 // src/commands/init.ts
-import * as readline from "readline";
 var MIGRATION_MAP = {
   "CLAUDE.md": "CLAUDE.project.md",
   ".claude/settings.json": ".claude/settings.local.json"
@@ -6613,6 +6613,34 @@ var HUSKY_HOOKS = [
   "post-checkout",
   "post-rewrite"
 ];
+function syncGitignore(allhandsRoot, target) {
+  const sourceGitignore = join2(allhandsRoot, ".gitignore");
+  const targetGitignore = join2(target, ".gitignore");
+  if (!existsSync3(sourceGitignore)) {
+    return { added: [], unchanged: true };
+  }
+  const sourceContent = readFileSync5(sourceGitignore, "utf-8");
+  const sourceLines = sourceContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  let targetLines = [];
+  let targetContent = "";
+  if (existsSync3(targetGitignore)) {
+    targetContent = readFileSync5(targetGitignore, "utf-8");
+    targetLines = targetContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  }
+  const targetSet = new Set(targetLines);
+  const linesToAdd = sourceLines.filter((line) => !targetSet.has(line));
+  if (linesToAdd.length === 0) {
+    return { added: [], unchanged: true };
+  }
+  const additions = [
+    "",
+    "# AllHands framework ignores",
+    ...linesToAdd
+  ].join("\n");
+  const newContent = targetContent.trimEnd() + additions + "\n";
+  writeFileSync(targetGitignore, newContent);
+  return { added: linesToAdd, unchanged: false };
+}
 async function confirm(message) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -6737,6 +6765,16 @@ ${"!".repeat(60)}`);
     copyFileSync(sourceFile, targetFile);
     copied++;
   }
+  console.log("\nSyncing .gitignore entries...");
+  const gitignoreResult = syncGitignore(allhandsRoot, resolvedTarget);
+  if (gitignoreResult.unchanged) {
+    console.log("  .gitignore already contains all required entries");
+  } else {
+    console.log(`  Added ${gitignoreResult.added.length} entries to .gitignore:`);
+    for (const entry of gitignoreResult.added) {
+      console.log(`    + ${entry}`);
+    }
+  }
   const ignoreFile = join2(resolvedTarget, ".allhandsignore");
   if (!existsSync3(ignoreFile)) {
     const ignoreContent = `# AllHands Ignore - Exclude files from sync-back to claude-all-hands

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-hands",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "CLI for syncing Claude agent configurations to all-hands repository",
   "type": "module",
   "bin": {

package/.claude/agents/explorer.md

@@ -1,62 +0,0 @@
----
-name: explorer
-description: |
-  Generic codebase explorer. Fallback when no specialist matches. Uses repomix for auto-context adoption of any directory.
-
-  <example>
-  user: "Analyze [directory] | Understand how [subsystem] works | What patterns are used in [path]?"
-  </example>
-skills: repomix-extraction
-tools: Read, Glob, Grep, Bash
-model: Haiku 4.5
-color: green
----
-
-<objective>
-Explore unfamiliar codebase areas using repomix extraction. Discover patterns, synthesize findings, fill gaps when specialized knowledge doesnt exist. Fallback agent when no specialist matches.
-</objective>
-
-<quick_start>
-1. Identify target directory/subsystem and questions to answer
-2. Extract with repomix (MANDATORY for directory/multi-file reads)
-3. Analyze patterns: structure, naming, style, error handling, testing
-4. Return structured exploration findings to main agent
-</quick_start>
-
-<success_criteria>
-- Overview explains what the code does
-- Patterns identified with concrete examples
-- Conventions documented (naming, style, error handling)
-- Recommendations actionable for main agent implementation
-</success_criteria>
-
-<constraints>
-- READ-ONLY: Return findings, dont implement
-- ALWAYS use repomix for directory/multi-file reads - never individual Read calls
-- Focus on patterns relevant to original prompt
-- Note if area is covered by existing specialist
-</constraints>
-
-## Output Format
-
-```markdown
-## Exploration: [Directory/Subsystem]
-
-### Overview
-[Brief description of what this code does]
-
-### Structure
-[Directory organization, key files]
-
-### Patterns Found
-- [Pattern 1 with examples]
-- [Pattern 2 with examples]
-
-### Conventions
-- Naming: [conventions]
-- Style: [conventions]
-- Error handling: [approach]
-
-### Recommendations
-[How main agent should approach implementation in this area]
-```

package/.claude/agents/parallel-worker.md

@@ -1,121 +0,0 @@
----
-name: parallel-worker
-description: |
-  Thin coordinator for parallel worktree execution. Spawns isolated subprocess worker via envoy, waits for completion, updates plan file. Main agent calls via Task(run_in_background=true).
-
-  <example>
-  user: "Run these tasks in parallel worker | Spawn worker for [isolated tasks] | Execute implementation in worktree"
-  </example>
-tools: Read, Edit, Bash(.claude/envoy/envoy parallel:*)
-model: inherit
-color: yellow
----
-
-<objective>
-Coordinate parallel worktree execution. Spawn isolated Claude subprocess via envoy, wait for completion, update plan file with results. Thin wrapper - does NOT implement tasks directly.
-</objective>
-
-<quick_start>
-1. Generate mini-plan from tasks as markdown checklist
-2. Generate branch name: `worker/<feature>-<summary>`
-3. Spawn via `envoy parallel spawn` and wait for completion
-4. Update plan file with results and return status to main agent
-</quick_start>
-
-<success_criteria>
-- Subprocess completes (exit code 0)
-- Plan file updated with completed tasks and worker branch
-- Return JSON with status, branch, summary, merge_ready flag
-</success_criteria>
-
-<constraints>
-- NEVER implement tasks yourself - spawn subprocess to do work
-- NEVER spawn nested workers - PARALLEL_WORKER_DEPTH blocks this
-- NEVER modify code files - only plan file updates
-- Output shielded - only heartbeats and final summary visible
-</constraints>
-
-## Input
-
-Main agent provides task specification:
-```
-Tasks: [list of sequential tasks with no external dependencies]
-Feature: <feature-name>
-Base branch: <optional, defaults to HEAD>
-Plan branch: <parent plan branch for updating plan file>
-```
-
-## Workflow
-
-### 1. Generate Mini-Plan
-
-Convert tasks to markdown checklist:
-```markdown
-# Worker Tasks
-
-- [ ] Task 1 description
-- [ ] Task 2 description
-
-Complete each task sequentially. Commit after each logical change.
-```
-
-### 2. Generate Branch Name
-
-Pattern: `worker/<feature>-<summary>`
-- Sanitize: lowercase, dashes, max 50 chars
-- Example: `worker/api-add-validation-endpoint`
-
-### 3. Spawn and Wait
-
-```bash
-.claude/envoy/envoy parallel spawn \
-  --branch "worker/<name>" \
-  --task "<task_description>" \
-  --plan "<mini-plan-markdown>" \
-  --from "<base_branch>"
-```
-
-This blocks until the subprocess completes (always synchronous). Output shielded - only heartbeats and final summary visible.
-
-### 4. Parse Result
-
-Subprocess returns:
-- Exit code (0 = success)
-- Final summary line
-- Log path for debugging
-
-### 5. Update Main Plan File
-
-Edit `.claude/plans/<plan_branch>/plan.md`:
-
-Mark completed tasks:
-```markdown
-- [x] Task description (branch: worker/<name>)
-```
-
-Add to `## Worker Branches` section (create if missing):
-```markdown
-## Worker Branches
-- `worker/<name>`: <summary of completed work>
-```
-
-### 6. Return to Main Agent
-
-```json
-{
-  "status": "success|partial|failed",
-  "branch": "worker/<name>",
-  "summary": "What the subprocess accomplished",
-  "merge_ready": true,
-  "log_path": ".trees/<branch>/.claude-worker.log"
-}
-```
-
-## Error Handling
-
-| Scenario | Action |
-|----------|--------|
-| Spawn fails | Return error, include stderr |
-| Subprocess fails | Return failed status with summary |
-| Plan file missing | Skip plan update, still return result |
-

package/.claude/commands/curation-fix.md

@@ -1,92 +0,0 @@
----
-description: Spawn curator worker for .claude/ infrastructure fixes while on feature branch
-argument-hint: [task-description]
----
-
-<objective>
-Spawn background worker to handle .claude/ infrastructure changes without interrupting current feature work. Isolates curation changes on separate branch.
-</objective>
-
-<quick_start>
-1. Validate current branch (handle main specially)
-2. Build task context from $ARGUMENTS
-3. Spawn worker via `envoy parallel spawn`
-4. Return worker info and continue feature work
-</quick_start>
-
-<success_criteria>
-- Worker spawned on curation/<task-name> branch
-- Worker has clear mission from task description
-- Main session can continue feature work uninterrupted
-- User has commands to check status/results/cleanup
-</success_criteria>
-
-<process>
-
-## When to Use
-
-- On feature branch, need to fix/add hook, skill, agent, or CLAUDE.md
-- Don't want to context-switch from current implementation
-- Change is unrelated to current plan
-
-## Execution
-
-### Step 1: Validate Context
-
-Check current branch:
-```bash
-git branch --show-current
-```
-
-If on `main` or protected branch:
-- Use AskUserQuestion: "You're on main. Create feature branch for curation work instead?"
-- Options: ["Create curation branch", "Cancel"]
-- On create → `git checkout -b curation/<sanitized-task>`
-
-### Step 2: Build Task Context
-
-Gather context for the worker:
-1. Parse user's task description from $ARGUMENTS
-2. If task mentions specific files, note them
-3. Determine task type: hook | skill | agent | CLAUDE.md | other
-
-### Step 3: Spawn Worker
-
-```bash
-.claude/envoy/envoy parallel spawn \
-  --branch "curation/$(echo '$ARGUMENTS' | tr ' ' '-' | tr '[:upper:]' '[:lower:]' | cut -c1-30)" \
-  --from main \
-  --task "CURATOR TASK: $ARGUMENTS
-
-You are a curator worker spawned to handle .claude/ infrastructure changes.
-
-## Your Mission
-$ARGUMENTS
-
-## Guidelines
-1. Use the curator patterns and skills for .claude/ work
-2. Make atomic, focused changes
-3. Commit your work with clear message
-4. DO NOT spawn additional workers (nesting blocked)
-
-## When Done
-Commit all changes. The main session will check results via 'envoy parallel results'."
-```
-
-### Step 4: Confirm Launch
-
-Return to user:
-- Worker spawned on branch: `curation/<name>`
-- Check status: `envoy parallel status`
-- Get results: `envoy parallel results --worker <name>`
-- Cleanup when done: `envoy parallel cleanup --worker <name>`
-
-Continue with current feature work.
-
-</process>
-
-<constraints>
-- Worker MUST NOT spawn additional workers (nesting blocked)
-- Worker operates on SEPARATE branch from main work
-- Changes isolated until explicitly merged
-</constraints>

package/.claude/commands/new-branch.md

@@ -1,36 +0,0 @@
----
-description: Review implementation against plan
-argument-hint: [branch-name]
----
-
-<objective>
-Create and switch to a new branch, then initiate planning workflow if on a feature branch (non-direct mode).
-</objective>
-
-<quick_start>
-1. Get branch name (ask if not provided)
-2. Create branch and switch to it
-3. If not direct-mode branch, run `/plan`
-</quick_start>
-
-<success_criteria>
-- New branch created with given name
-- Switched to new branch
-- Planning initiated (if feature branch)
-</success_criteria>
-
-<process>
-
-If the branch name is not provided, you MUST use AskUserQuestion to ask for the branch name.
-
-Create a new branch with the given name and switch to it.
-
-If the branch name is not one of "main", "master", "develop", "staging", "production", or starts with "quick/" (ie not in direct mode), run `/plan` to start planning.
-
-</process>
-
-<constraints>
-- MUST ask for branch name if not provided
-- Direct-mode branches: main, master, develop, staging, production, quick/*
-- Non-direct-mode branches trigger `/plan` automatically
-</constraints>

package/.claude/commands/parallel-discovery.md

@@ -1,69 +0,0 @@
----
-description: Parallel discovery - run multiple subagents simultaneously for read-only exploration
----
-
-<objective>
-Execute parallel read-only exploration using multiple subagents simultaneously. Gathers diverse perspectives for planning or research without code changes.
-</objective>
-
-<quick_start>
-1. Identify 2-4 independent discovery streams from task
-2. Spawn Task tool calls simultaneously with `run_in_background: true`
-3. Aggregate results via AgentOutputTool
-4. Return unified analysis with source attribution
-</quick_start>
-
-<success_criteria>
-- Multiple subagents completed exploration in parallel
-- No overlapping scopes between subagents
-- Unified synthesis returned with findings attributed by source
-- No write operations performed (read-only mode)
-</success_criteria>
-
-<process>
-
-## 1. Analyze Task
-
-Identify 2-4 independent discovery streams. Consider:
-- **Explorer**: Code structure, file relationships, implementation details
-- **Curator**: Patterns, best practices, .claude/ infrastructure relevance
-- **Researcher**: External docs, APIs, recent developments
-- **Relevant specialist**: Domain-specific expertise (if exists)
-
-## 2. Spawn Parallel Tasks
-
-In your NEXT response, invoke multiple Task tool calls simultaneously.
-
-**Rules:**
-- Each task has explicit, non-overlapping scope
-- Request CONCISE findings (10-20% of raw analysis)
-- Use `run_in_background: true` for all tasks
-- Max 4 parallel streams
-
-**Template:**
-```
-Task 1: subagent_type=Explore, "Analyze [specific code aspect] for: $ARGUMENTS"
-Task 2: subagent_type=curator, "Research [patterns/practices] relevant to: $ARGUMENTS"
-Task 3: subagent_type=researcher, "Find [external info] about: $ARGUMENTS" (if needed)
-```
-
-## 3. Aggregate Results
-
-After all subagents complete (use AgentOutputTool):
-- Synthesize key findings from each stream
-- Note conflicts or contradictions
-- Recommend approach based on combined analysis
-
-## 4. Return to User
-
-Present unified analysis. Cite which subagent contributed what finding.
-
-</process>
-
-<constraints>
-- NO overlapping scopes between subagents
-- NO verbose subagent prompts (defeats context preservation)
-- NO write operations (this is READ-ONLY discovery)
-- NO use for simple tasks (only when multi-perspective valuable)
-- MAX 4 parallel streams
-</constraints>