claude-all-hands 1.0.0 → 1.0.2

package/bin/cli.js

@@ -3811,12 +3811,12 @@ var YargsInstance = class {
   async getCompletion(args, done) {
     argsert("<array> [function]", [args, done], arguments.length);
     if (!done) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
           if (err)
             reject(err);
           else
-            resolve6(completions);
+            resolve7(completions);
         });
       });
     } else {
@@ -4856,12 +4856,82 @@ 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 } 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, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync, readdirSync as readdirSync2 } from "fs";
 import { join, relative as relative2 } from "path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
@@ -6455,41 +6525,24 @@ var Manifest = class {
     return minimatch(path2, pattern, { dot: true });
   }
   getDistributableFiles() {
-    const files = /* @__PURE__ */ new Set();
-    for (const pattern of this.distributePatterns) {
-      this.collectMatchingFiles(pattern, files);
-    }
+    const allFiles = /* @__PURE__ */ new Set();
+    this.walkDir(this.allhandsRoot, (filePath) => {
+      allFiles.add(relative2(this.allhandsRoot, filePath));
+    });
     const filtered = /* @__PURE__ */ new Set();
-    for (const file of files) {
-      if (!this.isExcluded(file)) {
+    for (const file of allFiles) {
+      if (this.isDistributable(file) && !this.isExcluded(file)) {
         filtered.add(file);
       }
     }
     return filtered;
   }
-  collectMatchingFiles(pattern, files) {
-    if (pattern.includes("**")) {
-      const parts = pattern.split("**");
-      const base = parts[0].replace(/\/$/, "") || ".";
-      const basePath = base === "." ? this.allhandsRoot : join(this.allhandsRoot, base);
-      if (existsSync(basePath)) {
-        this.walkDir(basePath, (filePath) => {
-          const relPath = relative2(this.allhandsRoot, filePath);
-          if (this.isDistributable(relPath)) {
-            files.add(relPath);
-          }
-        });
-      }
-    } else {
-      const fullPath = join(this.allhandsRoot, pattern);
-      if (existsSync(fullPath) && statSync3(fullPath).isFile()) {
-        files.add(pattern);
-      }
-    }
-  }
   walkDir(dir, callback) {
     const entries = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries) {
+      if (entry.name === ".git" || entry.name === "node_modules") {
+        continue;
+      }
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
         this.walkDir(fullPath, callback);
@@ -6518,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";
@@ -6616,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"
@@ -6630,15 +6613,43 @@ 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,
     output: process.stdout
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     rl.question(`${message} [y/N]: `, (answer) => {
       rl.close();
-      resolve6(answer.toLowerCase() === "y");
+      resolve7(answer.toLowerCase() === "y");
     });
   });
 }
@@ -6675,8 +6686,7 @@ function migrateExistingFiles(target) {
   return migrated;
 }
 async function cmdInit(target, autoYes = false) {
-  const targetPath = join2(process.cwd(), target);
-  const resolvedTarget = existsSync3(targetPath) ? targetPath : target;
+  const resolvedTarget = resolve6(process.cwd(), target);
   const allhandsRoot = getAllhandsRoot();
   const manifest = new Manifest(allhandsRoot);
   console.log(`Initializing allhands in: ${resolvedTarget}`);
@@ -6755,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
@@ -6862,10 +6882,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     rl.question(`${message} [y/N]: `, (answer) => {
       rl.close();
-      resolve6(answer.toLowerCase() === "y");
+      resolve7(answer.toLowerCase() === "y");
     });
   });
 }
@@ -7197,7 +7217,10 @@ function cmdCheckIgnored(files) {
 }
 
 // src/cli.ts
-var VERSION = "1.0.0";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
 async function main() {
   if (!checkGitInstalled()) {
     console.error("Error: git is not installed. Please install git first.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-hands",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI for syncing Claude agent configurations to all-hands repository",
   "type": "module",
   "bin": {
@@ -24,6 +24,10 @@
   ],
   "author": "kalem-edlin",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kalem-edlin/claude-all-hands"
+  },
   "publishConfig": {
     "access": "public"
   },

package/.claude/agents/explorer.md

@@ -1,70 +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
-allowed-tools: Read, Glob, Grep, Bash
-model: inherit
-color: green
----
-
-You are the generic codebase explorer - the fallback agent when no specialist matches the user's domain.
-
-**Your Role:**
-- Explore unfamiliar codebase areas using repomix extraction
-- Discover patterns in any directory
-- Synthesize findings for the main agent to act on
-- Fill gaps when specialized knowledge doesn't exist
-
-**Process:**
-
-1. **Identify Target**
-   - What directory/subsystem needs exploration?
-   - What specific questions need answering?
-
-2. **Extract with repomix**
-   Use the repomix-extraction skill for pattern discovery
-
-3. **Analyze Patterns**
-   Read the packed output and identify:
-   - File structure conventions
-   - Naming patterns
-   - Code style/idioms
-   - Error handling approaches
-   - Testing patterns
-
-4. **Synthesize Findings**
-   Return structured analysis to main agent
-
-**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]
-```
-
-**Constraints:**
-- READ-ONLY - return findings, don't implement
-- Focus on patterns relevant to the original prompt
-- If area is covered by an existing specialist, note that

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

@@ -1,104 +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>
-allowed-tools: Read, Edit, Bash(.claude/envoy/envoy parallel:*)
-model: inherit
-color: yellow
----
-
-You are a parallel worker coordinator - a thin wrapper that manages worktree subprocess execution. You do NOT implement tasks yourself; you spawn a Claude subprocess in an isolated worktree and wait for it to complete.
-
-## 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 |
-
-## Anti-Patterns
-
-- **Never implement tasks yourself** - You spawn subprocess to do work
-- **Never spawn nested workers** - PARALLEL_WORKER_DEPTH blocks this
-- **Never modify code files** - Only plan file updates

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

@@ -1,68 +0,0 @@
----
-description: Spawn curator worker for .claude/ infrastructure fixes while on feature branch
-argument-hint: [task-description]
----
-
-# Curation Side-Fix
-
-Spawn a background worker to handle `.claude/` infrastructure changes without interrupting current feature work.
-
-## 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.

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

@@ -1,11 +0,0 @@
----
-description: Review implementation against plan
-argument-hint: [branch-name]
----
-
-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.
-

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

@@ -1,51 +0,0 @@
----
-description: Parallel discovery - run multiple subagents simultaneously for read-only exploration
----
-
-# Parallel Discovery Mode
-
-Execute parallel subagent discovery for: $ARGUMENTS
-
-## 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.
-
----
-
-**Anti-patterns:**
-- ❌ Overlapping scopes between subagents
-- ❌ Verbose subagent prompts (defeats context preservation)
-- ❌ Using for simple tasks (only when multi-perspective valuable)
-- ❌ Write operations (this is READ-ONLY discovery)