homunculus-code 0.3.3 → 0.4.0

package/README.md

@@ -160,23 +160,23 @@ Homunculus — Self-evolving AI Assistant
 ✓ Created homunculus/ directory structure
 ✓ Added evolution rules
 ✓ Copied evolution scripts
-✓ Added slash commands (/hm-setup, /hm-night, /hm-status)
+✓ Added slash commands (/hm-goal, /hm-night, /hm-status)
 ✓ Configured observation hook
 
 Done! Homunculus is installed.
 
 Next steps:
   1. Run claude to open Claude Code
-  2. Type /hm-setup to define your goals (AI-guided)
+  2. Type /hm-goal to define your goals (AI-guided)
   3. Type /hm-night to run your first evolution cycle
 ```
 
 ### 2. Define Your Goals
 
-Open Claude Code and type `/hm-setup`. Claude will have a short conversation with you to understand your project and goals, then generate your `architecture.yaml` automatically.
+Open Claude Code and type `/hm-goal`. Claude will have a short conversation with you to understand your project and goals, then generate your `architecture.yaml` automatically.
 
 ```
-> /hm-setup
+> /hm-goal
 
 Claude: What kind of project is this?
 You:    A SaaS app for team collaboration
@@ -215,7 +215,7 @@ The observation hook watches your usage automatically. As patterns emerge:
 ```
 /hm-night       Run an evolution cycle
 /hm-status      Check evolution progress
-/hm-setup       Refine your goals anytime
+/hm-goal       Refine your goals anytime
 /eval-skill     Evaluate a specific skill
 /improve-skill  Auto-improve a skill
 /evolve         Converge instincts into skills

package/bin/init.js

@@ -76,7 +76,7 @@ This project uses Homunculus for goal-driven evolution.
 - **Goal Tree**: \`architecture.yaml\` — defines goals, metrics, and health checks
 - **Instincts**: \`homunculus/instincts/personal/\` — auto-extracted patterns
 - **Skills**: \`homunculus/evolved/skills/\` — tested, versioned knowledge
-- **Commands**: \`/hm-setup\` (define goals) | \`/hm-night\` (evolution cycle) | \`/hm-status\` (dashboard)
+- **Commands**: \`/hm-goal\` (define goals) | \`/hm-night\` (evolution cycle) | \`/hm-status\` (dashboard)
 `;
 
   if (fs.existsSync(claudeDest)) {
@@ -106,7 +106,7 @@ This project uses Homunculus for goal-driven evolution.
   // 5. Copy slash commands
   if (fs.existsSync(COMMANDS_DIR)) {
     copyDir(COMMANDS_DIR, path.join(projectDir, '.claude', 'commands'));
-    console.log('  \x1b[32m✓\x1b[0m Added slash commands (/hm-setup, /hm-night, /hm-status)');
+    console.log('  \x1b[32m✓\x1b[0m Added slash commands (/hm-goal, /hm-night, /hm-status)');
   }
 
   // 6. Configure Claude Code hooks
@@ -157,7 +157,7 @@ This project uses Homunculus for goal-driven evolution.
   console.log('');
   console.log('  Next steps:');
   console.log('    1. Run \x1b[1mclaude\x1b[0m to open Claude Code');
-  console.log('    2. Type \x1b[1m/hm-setup\x1b[0m to define your goals (AI-guided)');
+  console.log('    2. Type \x1b[1m/hm-goal\x1b[0m to define your goals (AI-guided)');
   console.log('    3. Type \x1b[1m/hm-night\x1b[0m to run your first evolution cycle');
   console.log('');
 }

package/commands/hm-goal.md

@@ -0,0 +1,124 @@
+# /hm-goal — View or Define Your Goal Tree
+
+If `architecture.yaml` exists, display the current goal tree and ask if changes are needed.
+If it doesn't exist, guide the user through creating one.
+
+**Always communicate in English** regardless of user's global Claude settings.
+
+## Behavior
+
+### Mode Detection
+
+Check if `architecture.yaml` exists in the project root.
+
+- **Exists** → Show Mode
+- **Doesn't exist** → Create Mode
+
+---
+
+## Show Mode (architecture.yaml exists)
+
+### Step 1: Read and display
+
+Read `architecture.yaml` and present the goal tree visually:
+
+```
+🎯 Your Goal Tree
+├── code_quality — Ship fewer bugs
+│   ├── testing — Every change has tests
+│   │   └── realized_by: skills/tdd-workflow.md ✓
+│   └── review — Catch issues before merge
+│       └── realized_by: # will evolve ○
+├── productivity — Move faster
+│   └── debugging — Find root causes faster
+│       └── realized_by: agents/debugger.md ✓
+└── knowledge — Stay current
+    └── tool_updates — Track useful updates
+        └── realized_by: # will evolve ○
+
+3 goals / 5 sub-goals
+2 implemented (✓) / 3 waiting to evolve (○)
+```
+
+### Step 2: Ask
+
+> "Want to add, remove, or change any goals?"
+
+- If yes → make the changes, update `architecture.yaml`
+- If no → done
+
+---
+
+## Create Mode (no architecture.yaml)
+
+**CRITICAL: Ask ONE question at a time. Wait for the answer before asking the next. Never batch multiple questions in one message.**
+
+### Step 1: Ask about the project (ONE question)
+
+> "What kind of project is this? (e.g., web app, CLI tool, API, personal project)"
+
+Wait for answer.
+
+### Step 2: Ask about pain points (ONE question)
+
+Based on their answer:
+> "What do you spend the most time on that you wish was better? (e.g., debugging, testing, deployment, keeping up with updates)"
+
+Wait for answer.
+
+### Step 3: Ask about priorities (ONE question)
+
+Based on their answer, ask ONE more targeted question. Examples:
+- "If your AI assistant could fix one thing overnight, what would it be?"
+- "What breaks most often in your workflow?"
+
+Adapt based on what they already told you. Wait for answer.
+
+### Step 4: Propose goals
+
+Based on ALL their answers, propose 3-5 goals with sub-goals:
+
+```
+Based on what you told me, here's your goal tree:
+
+🎯 [Project Name]
+├── code_quality — Ship fewer bugs
+│   ├── testing — Every change has tests
+│   └── review — Catch issues before merge
+├── productivity — Move faster
+│   └── debugging — Find root causes faster
+└── knowledge — Stay current
+    └── tool_updates — Track useful updates
+
+Does this look right? Want to add, remove, or change anything?
+```
+
+Wait for confirmation or changes.
+
+### Step 5: Generate architecture.yaml
+
+Once confirmed, generate `architecture.yaml` with:
+- `purpose` for every goal
+- `metrics` where measurable (use reasonable defaults)
+- `health_check` where possible (use the project's actual tech stack: `npm test`, `pytest`, `go test`, etc.)
+- `realized_by: # will evolve` for all implementations
+
+Write the file using the Write tool.
+
+### Step 6: Confirm
+
+```
+✅ architecture.yaml created with N goals!
+
+Your system is ready to evolve. Run /hm-night to start
+your first evolution cycle.
+```
+
+## Rules
+
+- **ONE question per message in Create Mode. Never ask two questions at once.**
+- Keep the whole setup under 5 back-and-forth messages
+- Generate PRACTICAL goals, not abstract ones
+- Don't overwhelm — 3-5 top-level goals is ideal
+- In Show Mode, show realized_by status (✓ = file exists, ○ = not yet)
+- Goals can always be refined by running `/hm-goal` again

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homunculus-code",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "A self-evolving AI assistant that grows smarter every night",
   "bin": {
     "homunculus-code": "./bin/cli.js"

package/commands/hm-setup.md

@@ -1,67 +0,0 @@
-# /hm-setup — Set Up Your Goal Tree
-
-Guide the user through defining their goals and generate `architecture.yaml`.
-
-**Always communicate in English** regardless of user's global Claude settings.
-
-## Behavior
-
-You are helping the user set up Homunculus — a self-evolving AI assistant. Your job is to understand their project and goals, then generate a goal tree.
-
-### Step 1: Understand the Project
-
-Ask the user (conversationally, not a form):
-- What is this project? (e.g., SaaS app, CLI tool, personal project)
-- What do they spend most time on? (e.g., debugging, writing tests, deploying)
-- What frustrates them? (e.g., regressions, slow CI, repetitive tasks)
-- What would they improve if they had infinite time?
-
-Keep it natural — 2-3 questions max, adapt based on answers.
-
-### Step 2: Propose Goals
-
-Based on their answers, propose 3-5 goals with sub-goals. Present them clearly:
-
-```
-Based on what you told me, here's your goal tree:
-
-🎯 [Project Name]
-├── code_quality — Ship fewer bugs
-│   ├── testing — Every change has tests
-│   └── review — Catch issues before merge
-├── productivity — Move faster
-│   ├── automation — Automate repetitive work
-│   └── debugging — Find root causes faster
-└── knowledge — Stay up to date
-    └── tool_updates — Track useful updates
-```
-
-Ask: "Does this look right? Want to add, remove, or change anything?"
-
-### Step 3: Generate architecture.yaml
-
-Once confirmed, generate `architecture.yaml` with:
-- `purpose` for every goal
-- `metrics` where measurable (use reasonable defaults)
-- `health_check` where possible (shell commands that exit 0 = healthy)
-- `realized_by: # will evolve` for all implementations (the system will fill these in)
-
-Write the file using the Write tool.
-
-### Step 4: Confirm
-
-```
-✅ architecture.yaml created with N goals!
-
-Your system is ready to evolve. Use Claude Code normally —
-patterns will be auto-extracted. Run /hm-night anytime to
-trigger an evolution cycle.
-```
-
-## Important
-
-- Keep the conversation SHORT (under 5 back-and-forth)
-- Generate PRACTICAL goals, not abstract ones
-- Use the project's actual tech stack for health checks (e.g., `npm test`, `pytest`, `go test`)
-- Don't overwhelm — 3-5 top-level goals is ideal for a start
-- Goals can always be refined later