@od-oneapp/ai-platform 0.1.0

package/src/tools/superpowers/tools/index.ts

@@ -0,0 +1,721 @@
+/**
+ * @fileoverview Superpowers Tools - Vercel AI SDK v6 tool implementations
+ * @module @od-oneapp/ai-platform/superpowers/tools
+ */
+
+import { z } from 'zod';
+
+import { tool } from '../../../shared';
+import {
+  ANTI_PATTERN_SYSTEM_PROMPT,
+  BRAINSTORM_SYSTEM_PROMPT,
+  CODE_REVIEW_SYSTEM_PROMPT,
+  COMMIT_ANALYSIS_SYSTEM_PROMPT,
+  CONDITION_BASED_WAITING_SYSTEM_PROMPT,
+  DEFENSE_IN_DEPTH_SYSTEM_PROMPT,
+  DESIGN_REVIEW_SYSTEM_PROMPT,
+  DISPATCHING_AGENTS_SYSTEM_PROMPT,
+  EXECUTING_PLANS_SYSTEM_PROMPT,
+  FINISHING_BRANCH_SYSTEM_PROMPT,
+  GIT_WORKTREE_SYSTEM_PROMPT,
+  PLANNER_SYSTEM_PROMPT,
+  RECEIVING_CODE_REVIEW_SYSTEM_PROMPT,
+  ROOT_CAUSE_TRACING_SYSTEM_PROMPT,
+  SHARING_SKILLS_SYSTEM_PROMPT,
+  SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT,
+  SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT,
+  TDD_SYSTEM_PROMPT,
+  TESTING_SKILLS_SYSTEM_PROMPT,
+  USING_SUPERPOWERS_SYSTEM_PROMPT,
+  WRITING_SKILLS_SYSTEM_PROMPT,
+} from '../prompts';
+import {
+  AgentDispatchOutputSchema,
+  AntiPatternOutputSchema,
+  AsyncPatternsOutputSchema,
+  BrainstormOutputSchema,
+  BranchFinishOutputSchema,
+  CodeReviewOutputSchema,
+  CodeReviewResponseOutputSchema,
+  CommitAnalysisOutputSchema,
+  DefenseInDepthOutputSchema,
+  DesignReviewOutputSchema,
+  PlanExecutionOutputSchema,
+  PlanOutputSchema,
+  RootCauseTracingOutputSchema,
+  SkillShareOutputSchema,
+  SkillTestOutputSchema,
+  SkillWriteOutputSchema,
+  SubagentDevOutputSchema,
+  SuperpowersIntroOutputSchema,
+  SystematicDebuggingOutputSchema,
+  TDDOutputSchema,
+  WorktreeOutputSchema,
+} from '../schemas';
+
+
+// Import generation utilities - these need to be provided by the consumer or we create stubs
+type GenerateValidatedObjectFn = <T>(
+  prompt: string,
+  schema: z.ZodType<T>,
+  options?: { system?: string },
+) => Promise<T>;
+
+/** Export the DI function type for consumers to implement */
+export type { GenerateValidatedObjectFn };
+
+let generateValidatedObjectImpl: GenerateValidatedObjectFn | null = null;
+
+/**
+ * Safe wrapper that throws a helpful error if not initialized
+ */
+function generateValidatedObject<T>(
+  prompt: string,
+  schema: z.ZodType<T>,
+  options?: { system?: string },
+): Promise<T> {
+  if (!generateValidatedObjectImpl) {
+    throw new Error(
+      'Superpowers not initialized. Call initSuperpowers({ generateValidatedObject }) before using any tools. ' +
+        'See @od-oneapp/ai-platform documentation for setup instructions.',
+    );
+  }
+  return generateValidatedObjectImpl(prompt, schema, options);
+}
+
+/**
+ * Check if superpowers have been initialized
+ */
+export function isSuperpowersInitialized(): boolean {
+  return generateValidatedObjectImpl !== null;
+}
+
+/**
+ * Initialize the superpowers module with required dependencies.
+ * Must be called before using any superpower tools.
+ *
+ * @example
+ * ```typescript
+ * import { initSuperpowers } from '@od-oneapp/ai-platform/superpowers';
+ * import { generateObject } from 'ai';
+ *
+ * initSuperpowers({
+ *   generateValidatedObject: async (prompt, schema, options) => {
+ *     const result = await generateObject({
+ *       model: yourModel,
+ *       prompt,
+ *       schema,
+ *       system: options?.system,
+ *     });
+ *     return result.object;
+ *   },
+ * });
+ * ```
+ */
+export function initSuperpowers(deps: { generateValidatedObject: GenerateValidatedObjectFn }) {
+  generateValidatedObjectImpl = deps.generateValidatedObject;
+}
+
+// ============================================================================
+// PLANNING TOOLS
+// ============================================================================
+
+export const refineRequirements = tool({
+  description:
+    'Analyze a vague or ambiguous request. Use this to brainstorm, identify edge cases, and generate clarifying questions before implementation.',
+  inputSchema: z.object({
+    rawRequest: z.string().describe("The user's original, potentially vague request"),
+    projectContext: z.string().optional().describe('Current tech stack or project constraints'),
+    existingCode: z.string().optional().describe('Relevant existing code snippets'),
+  }),
+  execute: async ({ rawRequest, projectContext, existingCode }) => {
+    return generateValidatedObject(
+      `Analyze this request: "${rawRequest}"
+${projectContext ? `\nProject Context: ${projectContext}` : ''}
+${existingCode ? `\nExisting Code:\n\`\`\`\n${existingCode}\n\`\`\`` : ''}`,
+      BrainstormOutputSchema,
+      { system: BRAINSTORM_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const consultArchitect = tool({
+  description:
+    'Create a detailed implementation plan before writing code. Use for complex features or refactoring tasks.',
+  inputSchema: z.object({
+    featureRequest: z.string().describe('The feature or change to plan'),
+    currentContext: z
+      .string()
+      .describe('Summary of relevant existing files, architecture, or constraints'),
+    constraints: z.array(z.string()).optional().describe('Technical or business constraints'),
+    existingCode: z.string().optional().describe('Relevant existing code to consider'),
+  }),
+  execute: async ({ featureRequest, currentContext, constraints, existingCode }) => {
+    return generateValidatedObject(
+      `Create an implementation plan for: "${featureRequest}"
+
+Current Context:
+${currentContext}
+
+${constraints ? `Constraints:\n${constraints.map(c => `- ${c}`).join('\n')}` : ''}
+${existingCode ? `\nRelevant Code:\n\`\`\`\n${existingCode}\n\`\`\`` : ''}`,
+      PlanOutputSchema,
+      { system: PLANNER_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const reviewDesign = tool({
+  description:
+    'Review proposed changes against project conventions and architecture. Use before major implementations.',
+  inputSchema: z.object({
+    proposedChanges: z.string().describe('Description of proposed changes'),
+    conventions: z.string().describe('Project conventions (e.g., from CLAUDE.md)'),
+    existingArchitecture: z.string().optional().describe('Current architecture description'),
+    affectedAreas: z.array(z.string()).optional().describe('Areas of codebase affected'),
+  }),
+  execute: async ({ proposedChanges, conventions, existingArchitecture, affectedAreas }) => {
+    return generateValidatedObject(
+      `Review this proposed change against project conventions:
+
+Proposed Changes:
+${proposedChanges}
+
+Project Conventions:
+${conventions}
+
+${existingArchitecture ? `\nExisting Architecture:\n${existingArchitecture}` : ''}
+${affectedAreas ? `\nAffected Areas:\n${affectedAreas.map(a => `- ${a}`).join('\n')}` : ''}`,
+      DesignReviewOutputSchema,
+      { system: DESIGN_REVIEW_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// QUALITY TOOLS
+// ============================================================================
+
+export const runTDDCycle = tool({
+  description:
+    'Guide implementation through Test-Driven Development (Red-Green-Refactor cycle). Use for new features that need thorough testing.',
+  inputSchema: z.object({
+    feature: z.string().describe('The feature to implement with TDD'),
+    testFramework: z.enum(['vitest', 'jest', 'mocha', 'playwright']).default('vitest'),
+    targetPath: z.string().describe('Path where implementation should go'),
+    existingTests: z.string().optional().describe('Existing test code to build upon'),
+    iteration: z.number().default(1).describe('Current TDD iteration number'),
+    previousResult: z.string().optional().describe('Result from previous iteration'),
+  }),
+  execute: async ({
+    feature,
+    testFramework,
+    targetPath,
+    existingTests,
+    iteration,
+    previousResult,
+  }) => {
+    return generateValidatedObject(
+      `TDD Iteration ${iteration} for: "${feature}"
+
+Target Path: ${targetPath}
+Test Framework: ${testFramework}
+${existingTests ? `\nExisting Tests:\n\`\`\`\n${existingTests}\n\`\`\`` : ''}
+${previousResult ? `\nPrevious Iteration Result:\n${previousResult}` : ''}
+
+${iteration === 1 ? 'Start by writing a failing test (RED phase).' : 'Continue the TDD cycle based on previous results.'}`,
+      TDDOutputSchema,
+      { system: TDD_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const reviewCode = tool({
+  description:
+    'Review code for security, performance, maintainability, and test coverage. Use before committing significant changes.',
+  inputSchema: z.object({
+    code: z.string().describe('The code to review'),
+    language: z.enum(['typescript', 'javascript', 'python', 'rust', 'go', 'java', 'other']),
+    context: z.string().optional().describe('Context about what this code does'),
+    projectConventions: z.string().optional().describe('Project-specific conventions to check'),
+    focusAreas: z
+      .array(z.enum(['security', 'performance', 'maintainability', 'testing']))
+      .optional(),
+  }),
+  execute: async ({ code, language, context, projectConventions, focusAreas }) => {
+    return generateValidatedObject(
+      `Review this ${language} code:
+
+\`\`\`${language}
+${code}
+\`\`\`
+
+${context ? `Context: ${context}` : ''}
+${projectConventions ? `\nProject Conventions:\n${projectConventions}` : ''}
+${focusAreas ? `\nFocus Areas: ${focusAreas.join(', ')}` : ''}`,
+      CodeReviewOutputSchema,
+      { system: CODE_REVIEW_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const detectAntiPatterns = tool({
+  description: 'Scan code for common anti-patterns and code smells. Use to maintain code quality.',
+  inputSchema: z.object({
+    code: z.string().describe('The code to analyze'),
+    filePath: z.string().describe('File path for context'),
+    language: z
+      .enum(['typescript', 'javascript', 'python', 'rust', 'go', 'java', 'other'])
+      .default('typescript'),
+    strictMode: z.boolean().default(false).describe('Enable strict checking for more issues'),
+  }),
+  execute: async ({ code, filePath, language, strictMode }) => {
+    return generateValidatedObject(
+      `Analyze this ${language} code for anti-patterns:
+
+File: ${filePath}
+Strict Mode: ${strictMode}
+
+\`\`\`${language}
+${code}
+\`\`\``,
+      AntiPatternOutputSchema,
+      { system: ANTI_PATTERN_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// DEBUGGING TOOLS
+// ============================================================================
+
+export const systematicDebug = tool({
+  description:
+    'Debug issues systematically using 4-phase root cause analysis. NO FIXES WITHOUT INVESTIGATION FIRST.',
+  inputSchema: z.object({
+    symptom: z.string().describe('The error message, unexpected behavior, or symptom observed'),
+    context: z.string().describe('Where and when the issue occurs'),
+    recentChanges: z.array(z.string()).optional().describe('Recent commits or changes'),
+    failingCode: z.string().optional().describe('Code that is failing'),
+  }),
+  execute: async ({ symptom, context, recentChanges, failingCode }) => {
+    return generateValidatedObject(
+      `Systematically debug this issue:
+
+Symptom: ${symptom}
+Context: ${context}
+${recentChanges ? `Recent Changes:\n${recentChanges.map(c => `- ${c}`).join('\n')}` : ''}
+${failingCode ? `\nFailing Code:\n\`\`\`\n${failingCode}\n\`\`\`` : ''}`,
+      SystematicDebuggingOutputSchema,
+      { system: SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const traceRootCause = tool({
+  description: 'Trace a symptom back through system layers to find the root cause.',
+  inputSchema: z.object({
+    symptom: z.string().describe('The observed symptom or error'),
+    systemLayers: z
+      .array(z.string())
+      .describe('System layers to trace through (UI, API, DB, etc.)'),
+    codeContext: z.string().optional().describe('Relevant code snippets'),
+  }),
+  execute: async ({ symptom, systemLayers, codeContext }) => {
+    return generateValidatedObject(
+      `Trace the root cause of this symptom:
+
+Symptom: ${symptom}
+System Layers: ${systemLayers.join(' → ')}
+${codeContext ? `\nCode Context:\n\`\`\`\n${codeContext}\n\`\`\`` : ''}`,
+      RootCauseTracingOutputSchema,
+      { system: ROOT_CAUSE_TRACING_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const analyzeDefenseInDepth = tool({
+  description: 'Analyze security layers and identify gaps in defense-in-depth strategy.',
+  inputSchema: z.object({
+    component: z.string().describe('Component or system to analyze'),
+    code: z.string().describe('Code to analyze for security layers'),
+    threatModel: z.string().optional().describe('Known threats to protect against'),
+  }),
+  execute: async ({ component, code, threatModel }) => {
+    return generateValidatedObject(
+      `Analyze defense-in-depth for this component:
+
+Component: ${component}
+${threatModel ? `Threat Model: ${threatModel}` : ''}
+
+Code:
+\`\`\`
+${code}
+\`\`\``,
+      DefenseInDepthOutputSchema,
+      { system: DEFENSE_IN_DEPTH_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const analyzeAsyncPatterns = tool({
+  description:
+    'Analyze async code and tests for proper waiting patterns. Identifies flaky patterns.',
+  inputSchema: z.object({
+    code: z.string().describe('Async code or test code to analyze'),
+    framework: z
+      .enum(['vitest', 'jest', 'playwright', 'cypress', 'other'])
+      .describe('Testing framework'),
+  }),
+  execute: async ({ code, framework }) => {
+    return generateValidatedObject(
+      `Analyze async patterns in this ${framework} code:
+
+\`\`\`
+${code}
+\`\`\``,
+      AsyncPatternsOutputSchema,
+      { system: CONDITION_BASED_WAITING_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// WORKFLOW TOOLS
+// ============================================================================
+
+export const executePlan = tool({
+  description: 'Execute an implementation plan step by step with human checkpoints.',
+  inputSchema: z.object({
+    plan: z.string().describe('The plan to execute (JSON or description)'),
+    currentStep: z.number().describe('Current step number to execute'),
+    previousResults: z.string().optional().describe('Results from previous steps'),
+  }),
+  execute: async ({ plan, currentStep, previousResults }) => {
+    return generateValidatedObject(
+      `Execute step ${currentStep} of this plan:
+
+Plan:
+${plan}
+
+${previousResults ? `Previous Results:\n${previousResults}` : ''}`,
+      PlanExecutionOutputSchema,
+      { system: EXECUTING_PLANS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const dispatchAgents = tool({
+  description: 'Decompose a task into parallel subtasks and coordinate agent execution.',
+  inputSchema: z.object({
+    task: z.string().describe('The task to decompose'),
+    availableAgents: z.array(z.string()).describe('Available agent types'),
+    constraints: z.string().optional().describe('Constraints on parallel execution'),
+  }),
+  execute: async ({ task, availableAgents, constraints }) => {
+    return generateValidatedObject(
+      `Decompose and dispatch agents for this task:
+
+Task: ${task}
+Available Agents: ${availableAgents.join(', ')}
+${constraints ? `Constraints: ${constraints}` : ''}`,
+      AgentDispatchOutputSchema,
+      { system: DISPATCHING_AGENTS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const runSubagentDev = tool({
+  description: 'Coordinate subagent-driven development with quality gates.',
+  inputSchema: z.object({
+    objective: z.string().describe('Development objective'),
+    qualityGates: z.array(z.string()).describe('Quality gates to pass'),
+    iteration: z.number().default(1).describe('Current iteration number'),
+  }),
+  execute: async ({ objective, qualityGates, iteration }) => {
+    return generateValidatedObject(
+      `Subagent-driven development iteration ${iteration}:
+
+Objective: ${objective}
+Quality Gates:
+${qualityGates.map(g => `- ${g}`).join('\n')}`,
+      SubagentDevOutputSchema,
+      { system: SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// CODE REVIEW RESPONSE TOOLS
+// ============================================================================
+
+export const processCodeReview = tool({
+  description: 'Process and respond to code review feedback constructively.',
+  inputSchema: z.object({
+    feedback: z.string().describe('The code review feedback received'),
+    originalCode: z.string().describe('The original code that was reviewed'),
+    reviewerId: z.string().optional().describe('Identifier for the reviewer'),
+  }),
+  execute: async ({ feedback, originalCode, reviewerId }) => {
+    return generateValidatedObject(
+      `Process this code review feedback:
+
+${reviewerId ? `Reviewer: ${reviewerId}` : ''}
+
+Feedback:
+${feedback}
+
+Original Code:
+\`\`\`
+${originalCode}
+\`\`\``,
+      CodeReviewResponseOutputSchema,
+      { system: RECEIVING_CODE_REVIEW_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// GIT TOOLS
+// ============================================================================
+
+export const analyzeCommit = tool({
+  description:
+    'Generate a semantic commit message by analyzing code changes. Use before git commit.',
+  inputSchema: z.object({
+    diff: z.string().describe('Git diff of changes'),
+    changedFiles: z.array(z.string()).describe('List of changed file paths'),
+    context: z.string().optional().describe('Additional context about the changes'),
+    relatedIssue: z.string().optional().describe('Related issue or ticket number'),
+  }),
+  execute: async ({ diff, changedFiles, context, relatedIssue }) => {
+    return generateValidatedObject(
+      `Analyze these code changes and generate a commit message:
+
+Changed Files:
+${changedFiles.map(f => `- ${f}`).join('\n')}
+
+${context ? `Context: ${context}` : ''}
+${relatedIssue ? `Related Issue: ${relatedIssue}` : ''}
+
+Diff:
+\`\`\`diff
+${diff}
+\`\`\``,
+      CommitAnalysisOutputSchema,
+      { system: COMMIT_ANALYSIS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const manageWorktree = tool({
+  description: 'Manage git worktrees for isolated feature development.',
+  inputSchema: z.object({
+    action: z.enum(['create', 'list', 'remove', 'switch']).describe('Worktree action to perform'),
+    branchName: z.string().optional().describe('Branch name for the worktree'),
+    baseBranch: z.string().optional().describe('Base branch to create from'),
+    path: z.string().optional().describe('Path for the worktree'),
+  }),
+  execute: async ({ action, branchName, baseBranch, path }) => {
+    return generateValidatedObject(
+      `Git worktree ${action}:
+
+${branchName ? `Branch: ${branchName}` : ''}
+${baseBranch ? `Base Branch: ${baseBranch}` : ''}
+${path ? `Path: ${path}` : ''}`,
+      WorktreeOutputSchema,
+      { system: GIT_WORKTREE_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const finishBranch = tool({
+  description: 'Complete and prepare a branch for merging with pre-flight checks.',
+  inputSchema: z.object({
+    branchName: z.string().describe('Branch to finish'),
+    targetBranch: z.string().describe('Target branch for merge'),
+    createPR: z.boolean().default(true).describe('Whether to create a PR'),
+  }),
+  execute: async ({ branchName, targetBranch, createPR }) => {
+    return generateValidatedObject(
+      `Finish branch and prepare for merge:
+
+Branch: ${branchName}
+Target: ${targetBranch}
+Create PR: ${createPR}`,
+      BranchFinishOutputSchema,
+      { system: FINISHING_BRANCH_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// META TOOLS
+// ============================================================================
+
+export const writeSkill = tool({
+  description: 'Create a new superpower/skill definition.',
+  inputSchema: z.object({
+    skillName: z.string().describe('Name of the skill to create'),
+    purpose: z.string().describe('What problem this skill solves'),
+    examples: z.array(z.string()).describe('Example use cases'),
+  }),
+  execute: async ({ skillName, purpose, examples }) => {
+    return generateValidatedObject(
+      `Create a new skill definition:
+
+Skill Name: ${skillName}
+Purpose: ${purpose}
+Examples:
+${examples.map(e => `- ${e}`).join('\n')}`,
+      SkillWriteOutputSchema,
+      { system: WRITING_SKILLS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const testSkill = tool({
+  description: 'Test a skill definition for quality and completeness.',
+  inputSchema: z.object({
+    skillDefinition: z.string().describe('The skill definition to test'),
+    testCases: z.array(z.string()).describe('Test cases to run'),
+  }),
+  execute: async ({
+    skillDefinition,
+    testCases,
+  }: {
+    skillDefinition: string;
+    testCases: string[];
+  }) => {
+    return generateValidatedObject(
+      `Test this skill definition:
+
+${skillDefinition}
+
+Test Cases:
+${testCases.map((t: string) => `- ${t}`).join('\n')}`,
+      SkillTestOutputSchema,
+      { system: TESTING_SKILLS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const shareSkill = tool({
+  description: 'Package a skill for sharing and distribution.',
+  inputSchema: z.object({
+    skillDefinition: z.string().describe('The skill to package'),
+    targetPlatforms: z.array(z.string()).describe('Target platforms for distribution'),
+    version: z.string().default('1.0.0').describe('Version number'),
+  }),
+  execute: async ({
+    skillDefinition,
+    targetPlatforms,
+    version,
+  }: {
+    skillDefinition: string;
+    targetPlatforms: string[];
+    version: string;
+  }) => {
+    return generateValidatedObject(
+      `Package skill for distribution:
+
+Version: ${version}
+Target Platforms: ${targetPlatforms.join(', ')}
+
+Skill:
+${skillDefinition}`,
+      SkillShareOutputSchema,
+      { system: SHARING_SKILLS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+export const introduceSuperpowers = tool({
+  description: 'Introduce the superpowers framework and guide usage.',
+  inputSchema: z.object({
+    projectContext: z.string().describe('Context about the project'),
+    userExperience: z.enum(['beginner', 'intermediate', 'expert']).default('intermediate'),
+  }),
+  execute: async ({
+    projectContext,
+    userExperience,
+  }: {
+    projectContext: string;
+    userExperience: 'beginner' | 'intermediate' | 'expert';
+  }) => {
+    return generateValidatedObject(
+      `Introduce superpowers framework:
+
+Project Context: ${projectContext}
+User Experience Level: ${userExperience}`,
+      SuperpowersIntroOutputSchema,
+      { system: USING_SUPERPOWERS_SYSTEM_PROMPT },
+    );
+  },
+});
+
+// ============================================================================
+// TOOL COLLECTIONS
+// ============================================================================
+
+export const planningTools = {
+  refineRequirements,
+  consultArchitect,
+  reviewDesign,
+} as const;
+
+export const qualityTools = {
+  runTDDCycle,
+  reviewCode,
+  detectAntiPatterns,
+} as const;
+
+export const debuggingTools = {
+  systematicDebug,
+  traceRootCause,
+  analyzeDefenseInDepth,
+  analyzeAsyncPatterns,
+} as const;
+
+export const workflowTools = {
+  executePlan,
+  dispatchAgents,
+  runSubagentDev,
+} as const;
+
+export const codeReviewTools = {
+  reviewCode,
+  processCodeReview,
+  detectAntiPatterns,
+} as const;
+
+export const gitTools = {
+  analyzeCommit,
+  manageWorktree,
+  finishBranch,
+} as const;
+
+export const metaTools = {
+  writeSkill,
+  testSkill,
+  shareSkill,
+  introduceSuperpowers,
+} as const;
+
+/**
+ * All superpower tools combined.
+ *
+ * NOTE: Some tools appear in multiple collections (e.g., `reviewCode` in both
+ * `qualityTools` and `codeReviewTools`, `detectAntiPatterns` in both `qualityTools`
+ * and `codeReviewTools`). This is intentional - tools can belong to multiple categories.
+ * The spread operator will use the last occurrence, so ensure consistent tool definitions.
+ */
+export const allSuperpowerTools = {
+  ...planningTools,
+  ...qualityTools,
+  ...debuggingTools,
+  ...workflowTools,
+  ...codeReviewTools,
+  ...gitTools,
+  ...metaTools,
+} as const;