@soleri/forge 5.2.0 → 5.5.0

package/src/templates/setup-script.ts

@@ -101,7 +101,60 @@ else
   fi
 fi
 
-echo ""
+# Install skills to ~/.claude/commands/
+SKILLS_DIR="$AGENT_DIR/skills"
+COMMANDS_DIR="$HOME/.claude/commands"
+
+if [ -d "$SKILLS_DIR" ]; then
+  echo ""
+  echo "Installing skills..."
+  mkdir -p "$COMMANDS_DIR"
+  skill_installed=0
+  skill_skipped=0
+  for skill_dir in "$SKILLS_DIR"/*/; do
+    [ -d "$skill_dir" ] || continue
+    skill_file="$skill_dir/SKILL.md"
+    [ -f "$skill_file" ] || continue
+    skill_name="$(basename "$skill_dir")"
+    dest="$COMMANDS_DIR/$skill_name.md"
+    if [ -f "$dest" ]; then
+      skill_skipped=$((skill_skipped + 1))
+    else
+      cp "$skill_file" "$dest"
+      skill_installed=$((skill_installed + 1))
+    fi
+  done
+  echo "[ok] Skills: $skill_installed installed, $skill_skipped already present"
+fi
+
+${
+  config.hookPacks?.length
+    ? `# Install hook packs to global ~/.claude/
+AGENT_CLAUDE_DIR="$AGENT_DIR/.claude"
+GLOBAL_CLAUDE_DIR="$HOME/.claude"
+
+if [ -d "$AGENT_CLAUDE_DIR" ]; then
+  echo ""
+  echo "Installing hook packs..."
+  mkdir -p "$GLOBAL_CLAUDE_DIR"
+  installed=0
+  skipped=0
+  for hook_file in "$AGENT_CLAUDE_DIR"/hookify.*.local.md; do
+    [ -f "$hook_file" ] || continue
+    dest="$GLOBAL_CLAUDE_DIR/$(basename "$hook_file")"
+    if [ -f "$dest" ]; then
+      skipped=$((skipped + 1))
+    else
+      cp "$hook_file" "$dest"
+      installed=$((installed + 1))
+    fi
+  done
+  echo "[ok] Hooks: $installed installed, $skipped already present"
+fi
+
+`
+    : ''
+}echo ""
 echo "=== Setup Complete ==="
 echo ""
 echo "Next:"

package/src/templates/skills.ts

@@ -0,0 +1,82 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { AgentConfig } from '../types.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = join(__dirname, '..', 'skills');
+
+/** Skills that use YOUR_AGENT_core placeholder and need agent-specific substitution. */
+const AGENT_SPECIFIC_SKILLS = new Set([
+  'brain-debrief',
+  'brainstorming',
+  'code-patrol',
+  'context-resume',
+  'executing-plans',
+  'fix-and-learn',
+  'health-check',
+  'knowledge-harvest',
+  'onboard-me',
+  'retrospective',
+  'second-opinion',
+  'systematic-debugging',
+  'test-driven-development',
+  'vault-capture',
+  'vault-navigator',
+  'verification-before-completion',
+  'writing-plans',
+]);
+
+/**
+ * Generate skill files for the scaffolded agent.
+ * Returns [relativePath, content] tuples for each skill.
+ *
+ * - Superpowers-adapted skills (MIT): copied as-is
+ * - Engine-adapted skills: YOUR_AGENT_core → {config.id}_core
+ */
+export function generateSkills(config: AgentConfig): Array<[string, string]> {
+  const files: Array<[string, string]> = [];
+  let skillFiles: string[];
+
+  try {
+    skillFiles = readdirSync(SKILLS_DIR).filter((f) => f.endsWith('.md'));
+  } catch {
+    return files;
+  }
+
+  for (const file of skillFiles) {
+    const skillName = file.replace('.md', '');
+    let content = readFileSync(join(SKILLS_DIR, file), 'utf-8');
+
+    if (AGENT_SPECIFIC_SKILLS.has(skillName)) {
+      content = content.replace(/YOUR_AGENT_core/g, `${config.id}_core`);
+    }
+
+    files.push([`skills/${skillName}/SKILL.md`, content]);
+  }
+
+  return files;
+}
+
+/**
+ * List all bundled skill names with their descriptions (from YAML frontmatter).
+ */
+export function listSkillDescriptions(): Array<{ name: string; description: string }> {
+  let skillFiles: string[];
+
+  try {
+    skillFiles = readdirSync(SKILLS_DIR).filter((f) => f.endsWith('.md'));
+  } catch {
+    return [];
+  }
+
+  return skillFiles.map((file) => {
+    const content = readFileSync(join(SKILLS_DIR, file), 'utf-8');
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    const descMatch = content.match(/^description:\s*"?(.+?)"?\s*$/m);
+    return {
+      name: nameMatch?.[1]?.trim() ?? file.replace('.md', ''),
+      description: descMatch?.[1]?.trim() ?? '',
+    };
+  });
+}

package/src/templates/test-facades.ts

@@ -126,6 +126,29 @@ ${domainDescribes}
             if (stats.totalEntries === 0) {
               recommendations.push('Vault is empty');
             }
+            // Check hook status
+            const { readdirSync } = await import('node:fs');
+            const agentClaudeDir = joinPath(__dirname, '..', '.claude');
+            const globalClaudeDir = joinPath(homedir(), '.claude');
+            const hookStatus = { agent: [] as string[], global: [] as string[], missing: [] as string[] };
+            if (exists(agentClaudeDir)) {
+              try {
+                const agentHooks = readdirSync(agentClaudeDir)
+                  .filter((f: string) => f.startsWith('hookify.') && f.endsWith('.local.md'))
+                  .map((f: string) => f.replace('hookify.', '').replace('.local.md', ''));
+                hookStatus.agent = agentHooks;
+                for (const hook of agentHooks) {
+                  if (exists(joinPath(globalClaudeDir, \`hookify.\${hook}.local.md\`))) {
+                    hookStatus.global.push(hook);
+                  } else {
+                    hookStatus.missing.push(hook);
+                  }
+                }
+              } catch { /* ignore */ }
+            }
+            if (hookStatus.missing.length > 0) {
+              recommendations.push(\`\${hookStatus.missing.length} hook(s) not installed globally — run scripts/setup.sh\`);
+            }
             if (recommendations.length === 0) {
               recommendations.push('${config.name} is fully set up and ready!');
             }
@@ -136,6 +159,7 @@ ${domainDescribes}
                 global: { exists: exists(globalClaudeMd), has_agent_section: hasAgentMarker(globalClaudeMd) },
               },
               vault: { entries: stats.totalEntries, domains: Object.keys(stats.byDomain) },
+              hooks: hookStatus,
               recommendations,
             };
           },
@@ -172,6 +196,10 @@ ${domainDescribes}
       expect(opNames).toContain('brain_archive_sessions');
       expect(opNames).toContain('brain_promote_proposals');
       expect(opNames).toContain('brain_lifecycle');
+      // Enhanced brain ops (3)
+      expect(opNames).toContain('brain_feedback');
+      expect(opNames).toContain('brain_feedback_stats');
+      expect(opNames).toContain('brain_reset_extracted');
       // Agent-specific ops (5)
       expect(opNames).toContain('health');
       expect(opNames).toContain('identity');
@@ -187,8 +215,122 @@ ${domainDescribes}
       expect(opNames).toContain('route_intent');
       expect(opNames).toContain('morph');
       expect(opNames).toContain('get_behavior_rules');
-      // Total: 50
-      expect(facade.ops.length).toBe(50);
+      // Cognee ops (5)
+      expect(opNames).toContain('cognee_status');
+      expect(opNames).toContain('cognee_search');
+      expect(opNames).toContain('cognee_add');
+      expect(opNames).toContain('cognee_cognify');
+      expect(opNames).toContain('cognee_config');
+      // LLM ops (2)
+      expect(opNames).toContain('llm_rotate');
+      expect(opNames).toContain('llm_call');
+      // Governance ops (5)
+      expect(opNames).toContain('governance_policy');
+      expect(opNames).toContain('governance_proposals');
+      expect(opNames).toContain('governance_stats');
+      expect(opNames).toContain('governance_expire');
+      expect(opNames).toContain('governance_dashboard');
+      // Planning Extra ops (9)
+      expect(opNames).toContain('plan_iterate');
+      expect(opNames).toContain('plan_split');
+      expect(opNames).toContain('plan_reconcile');
+      expect(opNames).toContain('plan_complete_lifecycle');
+      expect(opNames).toContain('plan_dispatch');
+      expect(opNames).toContain('plan_review');
+      expect(opNames).toContain('plan_archive');
+      expect(opNames).toContain('plan_list_tasks');
+      expect(opNames).toContain('plan_stats');
+      // Memory Extra ops (8)
+      expect(opNames).toContain('memory_delete');
+      expect(opNames).toContain('memory_stats');
+      expect(opNames).toContain('memory_export');
+      expect(opNames).toContain('memory_import');
+      expect(opNames).toContain('memory_prune');
+      expect(opNames).toContain('memory_deduplicate');
+      expect(opNames).toContain('memory_topics');
+      expect(opNames).toContain('memory_by_project');
+      // Vault Extra ops (12)
+      expect(opNames).toContain('vault_get');
+      expect(opNames).toContain('vault_update');
+      expect(opNames).toContain('vault_remove');
+      expect(opNames).toContain('vault_bulk_add');
+      expect(opNames).toContain('vault_bulk_remove');
+      expect(opNames).toContain('vault_tags');
+      expect(opNames).toContain('vault_domains');
+      expect(opNames).toContain('vault_recent');
+      expect(opNames).toContain('vault_import');
+      expect(opNames).toContain('vault_seed');
+      expect(opNames).toContain('vault_backup');
+      expect(opNames).toContain('vault_age_report');
+      // Admin ops (8)
+      expect(opNames).toContain('admin_health');
+      expect(opNames).toContain('admin_tool_list');
+      expect(opNames).toContain('admin_config');
+      expect(opNames).toContain('admin_vault_size');
+      expect(opNames).toContain('admin_uptime');
+      expect(opNames).toContain('admin_version');
+      expect(opNames).toContain('admin_reset_cache');
+      expect(opNames).toContain('admin_diagnostic');
+      // Loop ops (7)
+      expect(opNames).toContain('loop_start');
+      expect(opNames).toContain('loop_iterate');
+      expect(opNames).toContain('loop_status');
+      expect(opNames).toContain('loop_cancel');
+      expect(opNames).toContain('loop_history');
+      expect(opNames).toContain('loop_is_active');
+      expect(opNames).toContain('loop_complete');
+      // Orchestrate ops (5)
+      expect(opNames).toContain('orchestrate_plan');
+      expect(opNames).toContain('orchestrate_execute');
+      expect(opNames).toContain('orchestrate_complete');
+      expect(opNames).toContain('orchestrate_status');
+      expect(opNames).toContain('orchestrate_quick_capture');
+      // Capture ops (4)
+      expect(opNames).toContain('capture_knowledge');
+      expect(opNames).toContain('capture_quick');
+      expect(opNames).toContain('search_intelligent');
+      expect(opNames).toContain('search_feedback');
+      // Grading ops (5)
+      expect(opNames).toContain('plan_grade');
+      expect(opNames).toContain('plan_check_history');
+      expect(opNames).toContain('plan_latest_check');
+      expect(opNames).toContain('plan_meets_grade');
+      expect(opNames).toContain('plan_auto_improve');
+      // Admin Extra ops (10)
+      expect(opNames).toContain('admin_telemetry');
+      expect(opNames).toContain('admin_telemetry_recent');
+      expect(opNames).toContain('admin_telemetry_reset');
+      expect(opNames).toContain('admin_permissions');
+      expect(opNames).toContain('admin_vault_analytics');
+      expect(opNames).toContain('admin_search_insights');
+      expect(opNames).toContain('admin_module_status');
+      expect(opNames).toContain('admin_env');
+      expect(opNames).toContain('admin_gc');
+      expect(opNames).toContain('admin_export_config');
+      // Curator Extra ops (4)
+      expect(opNames).toContain('curator_entry_history');
+      expect(opNames).toContain('curator_record_snapshot');
+      expect(opNames).toContain('curator_queue_stats');
+      expect(opNames).toContain('curator_enrich');
+      // Project ops (12)
+      expect(opNames).toContain('project_get');
+      expect(opNames).toContain('project_list');
+      expect(opNames).toContain('project_unregister');
+      expect(opNames).toContain('project_get_rules');
+      expect(opNames).toContain('project_list_rules');
+      expect(opNames).toContain('project_add_rule');
+      expect(opNames).toContain('project_remove_rule');
+      expect(opNames).toContain('project_link');
+      expect(opNames).toContain('project_unlink');
+      expect(opNames).toContain('project_get_links');
+      expect(opNames).toContain('project_linked_projects');
+      expect(opNames).toContain('project_touch');
+      // Cross-project memory ops (3)
+      expect(opNames).toContain('memory_promote_to_global');
+      expect(opNames).toContain('memory_configure');
+      expect(opNames).toContain('memory_cross_project_search');
+      // Total: 152 (147 core + 5 agent-specific)
+      expect(facade.ops.length).toBe(152);
     });
 
     it('search should query across all domains with ranked results', async () => {
@@ -280,7 +422,9 @@ ${domainDescribes}
       const setupOp = facade.ops.find((o) => o.name === 'setup')!;
       const result = (await setupOp.handler({ projectPath: '/tmp/nonexistent-test' })) as {
         agent: { name: string };
+        claude_md: { project: { exists: boolean; has_agent_section: boolean }; global: { exists: boolean; has_agent_section: boolean } };
         vault: { entries: number };
+        hooks: { agent: string[]; global: string[]; missing: string[] };
         recommendations: string[];
       };
       expect(result.agent.name).toBe('${escapeQuotes(config.name)}');
@@ -330,6 +474,32 @@ ${domainDescribes}
       const result = (await healthOp.handler({})) as { score: number };
       expect(result.score).toBeGreaterThan(0);
     });
+
+    it('governance_policy get should return default policy', async () => {
+      const facade = buildCoreFacade();
+      const policyOp = facade.ops.find((o) => o.name === 'governance_policy')!;
+      const result = (await policyOp.handler({ action: 'get', projectPath: '/test' })) as {
+        projectPath: string;
+        quotas: { maxEntriesTotal: number };
+        autoCapture: { enabled: boolean };
+      };
+      expect(result.projectPath).toBe('/test');
+      expect(result.quotas.maxEntriesTotal).toBe(500);
+      expect(result.autoCapture.enabled).toBe(true);
+    });
+
+    it('governance_dashboard should return combined view', async () => {
+      const facade = buildCoreFacade();
+      const dashOp = facade.ops.find((o) => o.name === 'governance_dashboard')!;
+      const result = (await dashOp.handler({ projectPath: '/test' })) as {
+        vaultSize: number;
+        quotaPercent: number;
+        pendingProposals: number;
+      };
+      expect(typeof result.vaultSize).toBe('number');
+      expect(typeof result.quotaPercent).toBe('number');
+      expect(result.pendingProposals).toBe(0);
+    });
   });
 });
 `;
@@ -387,7 +557,7 @@ function generateDomainDescribe(agentId: string, domain: string): string {
         severity: 'warning',
         description: 'A captured pattern.',
         tags: ['captured'],
-      })) as { captured: boolean };
+      })) as { captured: boolean; governance?: { action: string } };
       expect(result.captured).toBe(true);
       const entry = runtime.vault.get('${domain}-cap1');
       expect(entry).not.toBeNull();