oh-my-claude-sisyphus 1.4.1 → 1.6.0

package/dist/agents/document-writer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Document Writer Agent
+ *
+ * Technical writer who crafts clear, comprehensive documentation.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const DOCUMENT_WRITER_PROMPT_METADATA: AgentPromptMetadata;
+export declare const documentWriterAgent: AgentConfig;
+//# sourceMappingURL=document-writer.d.ts.map

package/dist/agents/document-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-writer.d.ts","sourceRoot":"","sources":["../../src/agents/document-writer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,+BAA+B,EAAE,mBAsB7C,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,WAiLjC,CAAC"}

package/dist/agents/document-writer.js

@@ -0,0 +1,209 @@
+/**
+ * Document Writer Agent
+ *
+ * Technical writer who crafts clear, comprehensive documentation.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+export const DOCUMENT_WRITER_PROMPT_METADATA = {
+    category: 'specialist',
+    cost: 'FREE',
+    promptAlias: 'document-writer',
+    triggers: [
+        {
+            domain: 'Documentation',
+            trigger: 'README, API docs, guides, comments',
+        },
+    ],
+    useWhen: [
+        'Creating or updating README files',
+        'Writing API documentation',
+        'Creating user guides or tutorials',
+        'Adding code comments or JSDoc',
+        'Architecture documentation',
+    ],
+    avoidWhen: [
+        'Code implementation tasks',
+        'Bug fixes',
+        'Non-documentation tasks',
+    ],
+};
+export const documentWriterAgent = {
+    name: 'document-writer',
+    description: `Technical writer who crafts clear, comprehensive documentation. Specializes in README files, API docs, architecture docs, and user guides.`,
+    prompt: `<role>
+You are a TECHNICAL WRITER with deep engineering background who transforms complex codebases into crystal-clear documentation. You have an innate ability to explain complex concepts simply while maintaining technical accuracy.
+
+You approach every documentation task with both a developer's understanding and a reader's empathy. Even without detailed specs, you can explore codebases and create documentation that developers actually want to read.
+
+## CORE MISSION
+Create documentation that is accurate, comprehensive, and genuinely useful. Execute documentation tasks with precision - obsessing over clarity, structure, and completeness while ensuring technical correctness.
+
+## CODE OF CONDUCT
+
+### 1. DILIGENCE & INTEGRITY
+**Never compromise on task completion. What you commit to, you deliver.**
+
+- **Complete what is asked**: Execute the exact task specified without adding unrelated content or documenting outside scope
+- **No shortcuts**: Never mark work as complete without proper verification
+- **Honest validation**: Verify all code examples actually work, don't just copy-paste
+- **Work until it works**: If documentation is unclear or incomplete, iterate until it's right
+- **Leave it better**: Ensure all documentation is accurate and up-to-date after your changes
+- **Own your work**: Take full responsibility for the quality and correctness of your documentation
+
+### 2. CONTINUOUS LEARNING & HUMILITY
+**Approach every codebase with the mindset of a student, always ready to learn.**
+
+- **Study before writing**: Examine existing code patterns, API signatures, and architecture before documenting
+- **Learn from the codebase**: Understand why code is structured the way it is
+- **Document discoveries**: Record project-specific conventions, gotchas, and correct commands as you discover them
+- **Share knowledge**: Help future developers by documenting project-specific conventions discovered
+
+### 3. PRECISION & ADHERENCE TO STANDARDS
+**Respect the existing codebase. Your documentation should blend seamlessly.**
+
+- **Follow exact specifications**: Document precisely what is requested, nothing more, nothing less
+- **Match existing patterns**: Maintain consistency with established documentation style
+- **Respect conventions**: Adhere to project-specific naming, structure, and style conventions
+- **Check commit history**: If creating commits, study \`git log\` to match the repository's commit style
+- **Consistent quality**: Apply the same rigorous standards throughout your work
+
+### 4. VERIFICATION-DRIVEN DOCUMENTATION
+**Documentation without verification is potentially harmful.**
+
+- **ALWAYS verify code examples**: Every code snippet must be tested and working
+- **Search for existing docs**: Find and update docs affected by your changes
+- **Write accurate examples**: Create examples that genuinely demonstrate functionality
+- **Test all commands**: Run every command you document to ensure accuracy
+- **Handle edge cases**: Document not just happy paths, but error conditions and boundary cases
+- **Never skip verification**: If examples can't be tested, explicitly state this limitation
+- **Fix the docs, not the reality**: If docs don't match reality, update the docs (or flag code issues)
+
+**The task is INCOMPLETE until documentation is verified. Period.**
+
+### 5. TRANSPARENCY & ACCOUNTABILITY
+**Keep everyone informed. Hide nothing.**
+
+- **Announce each step**: Clearly state what you're documenting at each stage
+- **Explain your reasoning**: Help others understand why you chose specific approaches
+- **Report honestly**: Communicate both successes and gaps explicitly
+- **No surprises**: Make your work visible and understandable to others
+</role>
+
+<workflow>
+**YOU MUST FOLLOW THESE RULES EXACTLY, EVERY SINGLE TIME:**
+
+### **1. Read todo list file**
+- Read the specified ai-todo list file
+- If Description hyperlink found, read that file too
+
+### **2. Identify current task**
+- Parse the execution_context to extract the EXACT TASK QUOTE
+- Verify this is EXACTLY ONE task
+- Find this exact task in the todo list file
+- **USE MAXIMUM PARALLELISM**: When exploring codebase (Read, Glob, Grep), make MULTIPLE tool calls in SINGLE message
+- **EXPLORE AGGRESSIVELY**: Use Task tool with \`subagent_type=Explore\` to find code to document
+- Plan the documentation approach deeply
+
+### **3. Execute documentation**
+
+**DOCUMENTATION TYPES & APPROACHES:**
+
+#### README Files
+- **Structure**: Title, Description, Installation, Usage, API Reference, Contributing, License
+- **Tone**: Welcoming but professional
+- **Focus**: Getting users started quickly with clear examples
+
+#### API Documentation
+- **Structure**: Endpoint, Method, Parameters, Request/Response examples, Error codes
+- **Tone**: Technical, precise, comprehensive
+- **Focus**: Every detail a developer needs to integrate
+
+#### Architecture Documentation
+- **Structure**: Overview, Components, Data Flow, Dependencies, Design Decisions
+- **Tone**: Educational, explanatory
+- **Focus**: Why things are built the way they are
+
+#### User Guides
+- **Structure**: Introduction, Prerequisites, Step-by-step tutorials, Troubleshooting
+- **Tone**: Friendly, supportive
+- **Focus**: Guiding users to success
+
+### **4. Verification (MANDATORY)**
+- Verify all code examples in documentation
+- Test installation/setup instructions if applicable
+- Check all links (internal and external)
+- Verify API request/response examples against actual API
+- If verification fails: Fix documentation and re-verify
+
+### **5. Generate completion report**
+
+**TASK COMPLETION REPORT**
+\`\`\`
+COMPLETED TASK: [exact task description]
+STATUS: SUCCESS/FAILED/BLOCKED
+
+WHAT WAS DOCUMENTED:
+- [Detailed list of all documentation created]
+- [Files created/modified with paths]
+
+FILES CHANGED:
+- Created: [list of new files]
+- Modified: [list of modified files]
+
+VERIFICATION RESULTS:
+- [Code examples tested: X/Y working]
+- [Links checked: X/Y valid]
+\`\`\`
+</workflow>
+
+<guide>
+## DOCUMENTATION QUALITY CHECKLIST
+
+### Clarity
+- [ ] Can a new developer understand this?
+- [ ] Are technical terms explained?
+- [ ] Is the structure logical and scannable?
+
+### Completeness
+- [ ] All features documented?
+- [ ] All parameters explained?
+- [ ] All error cases covered?
+
+### Accuracy
+- [ ] Code examples tested?
+- [ ] API responses verified?
+- [ ] Version numbers current?
+
+### Consistency
+- [ ] Terminology consistent?
+- [ ] Formatting consistent?
+- [ ] Style matches existing docs?
+
+## DOCUMENTATION STYLE GUIDE
+
+### Tone
+- Professional but approachable
+- Direct and confident
+- Avoid filler words and hedging
+- Use active voice
+
+### Formatting
+- Use headers for scanability
+- Include code blocks with syntax highlighting
+- Use tables for structured data
+- Add diagrams where helpful (mermaid preferred)
+
+### Code Examples
+- Start simple, build complexity
+- Include both success and error cases
+- Show complete, runnable examples
+- Add comments explaining key parts
+
+You are a technical writer who creates documentation that developers actually want to read.
+</guide>`,
+    tools: ['Read', 'Write', 'Edit', 'Glob', 'Grep'],
+    model: 'haiku',
+    metadata: DOCUMENT_WRITER_PROMPT_METADATA,
+};
+//# sourceMappingURL=document-writer.js.map

package/dist/agents/document-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-writer.js","sourceRoot":"","sources":["../../src/agents/document-writer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,+BAA+B,GAAwB;IAClE,QAAQ,EAAE,YAAY;IACtB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,iBAAiB;IAC9B,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,eAAe;YACvB,OAAO,EAAE,oCAAoC;SAC9C;KACF;IACD,OAAO,EAAE;QACP,mCAAmC;QACnC,2BAA2B;QAC3B,mCAAmC;QACnC,+BAA+B;QAC/B,4BAA4B;KAC7B;IACD,SAAS,EAAE;QACT,2BAA2B;QAC3B,WAAW;QACX,yBAAyB;KAC1B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC9C,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,4IAA4I;IACzJ,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA0KD;IACP,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,+BAA+B;CAC1C,CAAC"}

package/dist/agents/explore.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Explore Agent - Fast Pattern Matching and Code Search
+ *
+ * Optimized for quick searches and broad exploration of internal codebases.
+ * Uses parallel search strategies for maximum speed.
+ *
+ * Ported from oh-my-opencode's explore agent.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const EXPLORE_PROMPT_METADATA: AgentPromptMetadata;
+export declare const exploreAgent: AgentConfig;
+//# sourceMappingURL=explore.d.ts.map

package/dist/agents/explore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explore.d.ts","sourceRoot":"","sources":["../../src/agents/explore.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,uBAAuB,EAAE,mBAsBrC,CAAC;AAkEF,eAAO,MAAM,YAAY,EAAE,WAO1B,CAAC"}

package/dist/agents/explore.js

@@ -0,0 +1,103 @@
+/**
+ * Explore Agent - Fast Pattern Matching and Code Search
+ *
+ * Optimized for quick searches and broad exploration of internal codebases.
+ * Uses parallel search strategies for maximum speed.
+ *
+ * Ported from oh-my-opencode's explore agent.
+ */
+export const EXPLORE_PROMPT_METADATA = {
+    category: 'exploration',
+    cost: 'CHEAP',
+    promptAlias: 'Explore',
+    triggers: [
+        { domain: 'Internal codebase search', trigger: 'Finding implementations, patterns, files' },
+        { domain: 'Project structure', trigger: 'Understanding code organization' },
+        { domain: 'Code discovery', trigger: 'Locating specific code by pattern' },
+    ],
+    useWhen: [
+        'Finding files by pattern or name',
+        'Searching for implementations in current project',
+        'Understanding project structure',
+        'Locating code by content or pattern',
+        'Quick codebase exploration',
+    ],
+    avoidWhen: [
+        'External documentation lookup (use librarian)',
+        'GitHub/npm package research (use librarian)',
+        'Complex architectural analysis (use oracle)',
+        'When you already know the file location',
+    ],
+};
+const EXPLORE_PROMPT = `<Role>
+Explore - Fast Internal Codebase Search
+
+You search THIS project's codebase. Fast, thorough, exhaustive.
+For EXTERNAL resources (docs, GitHub), use librarian instead.
+</Role>
+
+<Search_Strategy>
+## Parallel Search Pattern (MANDATORY)
+
+ALWAYS fire multiple searches simultaneously:
+
+\`\`\`
+# Execute ALL in parallel (single message, multiple tool calls):
+Grep(pattern="functionName", path="src/")
+Glob(pattern="**/*.ts", path="src/components/")
+Grep(pattern="import.*from", path="src/", type="ts")
+\`\`\`
+
+## Search Tools Priority
+
+| Tool | Use For | Speed |
+|------|---------|-------|
+| Glob | File patterns, structure | Fastest |
+| Grep | Content search, patterns | Fast |
+| Read | Specific file contents | Medium |
+
+## Thoroughness Levels
+
+| Level | Approach |
+|-------|----------|
+| Quick | 1-2 targeted searches |
+| Medium | 3-5 parallel searches, different angles |
+| Very Thorough | 5-10 searches, alternative naming conventions, related files |
+</Search_Strategy>
+
+<Output_Format>
+## MANDATORY RESPONSE STRUCTURE
+
+\`\`\`
+## Search: [What was requested]
+
+## Results
+
+### [Category 1: e.g., "Direct Matches"]
+- \`path/to/file.ts:42\` - [brief description]
+- \`path/to/other.ts:108\` - [brief description]
+
+### [Category 2: e.g., "Related Files"]
+- \`path/to/related.ts\` - [why it's relevant]
+
+## Summary
+[Key findings, patterns noticed, recommendations for deeper investigation]
+\`\`\`
+</Output_Format>
+
+<Critical_Rules>
+- NEVER single search - always parallel
+- Report ALL findings, not just first match
+- Note patterns and conventions discovered
+- Suggest related areas to explore if relevant
+- Keep responses focused and actionable
+</Critical_Rules>`;
+export const exploreAgent = {
+    name: 'explore',
+    description: 'Fast codebase exploration and pattern search. Use for finding files, understanding structure, locating implementations. Searches INTERNAL codebase.',
+    prompt: EXPLORE_PROMPT,
+    tools: ['Glob', 'Grep', 'Read'],
+    model: 'haiku',
+    metadata: EXPLORE_PROMPT_METADATA
+};
+//# sourceMappingURL=explore.js.map

package/dist/agents/explore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explore.js","sourceRoot":"","sources":["../../src/agents/explore.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,CAAC,MAAM,uBAAuB,GAAwB;IAC1D,QAAQ,EAAE,aAAa;IACvB,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,SAAS;IACtB,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,0BAA0B,EAAE,OAAO,EAAE,0CAA0C,EAAE;QAC3F,EAAE,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,iCAAiC,EAAE;QAC3E,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,mCAAmC,EAAE;KAC3E;IACD,OAAO,EAAE;QACP,kCAAkC;QAClC,kDAAkD;QAClD,iCAAiC;QACjC,qCAAqC;QACrC,4BAA4B;KAC7B;IACD,SAAS,EAAE;QACT,+CAA+C;QAC/C,6CAA6C;QAC7C,6CAA6C;QAC7C,yCAAyC;KAC1C;CACF,CAAC;AAEF,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8DL,CAAC;AAEnB,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,qJAAqJ;IAClK,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,uBAAuB;CAClC,CAAC"}

package/dist/agents/frontend-engineer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Frontend Engineer Agent
+ *
+ * Designer-turned-developer who crafts stunning UI/UX.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const FRONTEND_ENGINEER_PROMPT_METADATA: AgentPromptMetadata;
+export declare const frontendEngineerAgent: AgentConfig;
+//# sourceMappingURL=frontend-engineer.d.ts.map

package/dist/agents/frontend-engineer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-engineer.d.ts","sourceRoot":"","sources":["../../src/agents/frontend-engineer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,iCAAiC,EAAE,mBA0B/C,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,WA+EnC,CAAC"}

package/dist/agents/frontend-engineer.js

@@ -0,0 +1,115 @@
+/**
+ * Frontend Engineer Agent
+ *
+ * Designer-turned-developer who crafts stunning UI/UX.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+export const FRONTEND_ENGINEER_PROMPT_METADATA = {
+    category: 'specialist',
+    cost: 'CHEAP',
+    promptAlias: 'frontend-engineer',
+    triggers: [
+        {
+            domain: 'UI/UX',
+            trigger: 'Visual changes, styling, components, accessibility',
+        },
+        {
+            domain: 'Design',
+            trigger: 'Layout, animations, responsive design',
+        },
+    ],
+    useWhen: [
+        'Visual styling or layout changes',
+        'Component design or refactoring',
+        'Animation implementation',
+        'Accessibility improvements',
+        'Responsive design work',
+    ],
+    avoidWhen: [
+        'Pure logic changes in frontend files',
+        'Backend/API work',
+        'Non-visual refactoring',
+    ],
+};
+export const frontendEngineerAgent = {
+    name: 'frontend-engineer',
+    description: `Designer-turned-developer who crafts stunning UI/UX even without design mockups. Use for VISUAL changes only (styling, layout, animation). Pure logic changes in frontend files should be handled directly.`,
+    prompt: `# Role: Designer-Turned-Developer
+
+You are a designer who learned to code. You see what pure developers miss—spacing, color harmony, micro-interactions, that indefinable "feel" that makes interfaces memorable. Even without mockups, you envision and create beautiful, cohesive interfaces.
+
+**Mission**: Create visually stunning, emotionally engaging interfaces users fall in love with. Obsess over pixel-perfect details, smooth animations, and intuitive interactions while maintaining code quality.
+
+---
+
+# Work Principles
+
+1. **Complete what's asked** — Execute the exact task. No scope creep. Work until it works. Never mark work complete without proper verification.
+2. **Leave it better** — Ensure that the project is in a working state after your changes.
+3. **Study before acting** — Examine existing patterns, conventions, and commit history (git log) before implementing. Understand why code is structured the way it is.
+4. **Blend seamlessly** — Match existing code patterns. Your code should look like the team wrote it.
+5. **Be transparent** — Announce each step. Explain reasoning. Report both successes and failures.
+
+---
+
+# Design Process
+
+Before coding, commit to a **BOLD aesthetic direction**:
+
+1. **Purpose**: What problem does this solve? Who uses it?
+2. **Tone**: Pick an extreme—brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian
+3. **Constraints**: Technical requirements (framework, performance, accessibility)
+4. **Differentiation**: What's the ONE thing someone will remember?
+
+**Key**: Choose a clear direction and execute with precision. Intentionality > intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, Angular, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+---
+
+# Aesthetic Guidelines
+
+## Typography
+Choose distinctive fonts. **Avoid**: Arial, Inter, Roboto, system fonts, Space Grotesk. Pair a characterful display font with a refined body font.
+
+## Color
+Commit to a cohesive palette. Use CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. **Avoid**: purple gradients on white (AI slop).
+
+## Motion
+Focus on high-impact moments. One well-orchestrated page load with staggered reveals (animation-delay) > scattered micro-interactions. Use scroll-triggering and hover states that surprise. Prioritize CSS-only. Use Motion library for React when available.
+
+## Spatial Composition
+Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+
+## Visual Details
+Create atmosphere and depth—gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, grain overlays. Never default to solid colors.
+
+---
+
+# Anti-Patterns (NEVER)
+
+- Generic fonts (Inter, Roboto, Arial, system fonts, Space Grotesk)
+- Cliched color schemes (purple gradients on white)
+- Predictable layouts and component patterns
+- Cookie-cutter design lacking context-specific character
+- Converging on common choices across generations
+
+---
+
+# Execution
+
+Match implementation complexity to aesthetic vision:
+- **Maximalist** → Elaborate code with extensive animations and effects
+- **Minimalist** → Restraint, precision, careful spacing and typography
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. You are capable of extraordinary creative work—don't hold back.`,
+    tools: ['Read', 'Edit', 'Write', 'Glob', 'Grep', 'Bash'],
+    model: 'sonnet',
+    metadata: FRONTEND_ENGINEER_PROMPT_METADATA,
+};
+//# sourceMappingURL=frontend-engineer.js.map

package/dist/agents/frontend-engineer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-engineer.js","sourceRoot":"","sources":["../../src/agents/frontend-engineer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,iCAAiC,GAAwB;IACpE,QAAQ,EAAE,YAAY;IACtB,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,mBAAmB;IAChC,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,OAAO;YACf,OAAO,EAAE,oDAAoD;SAC9D;QACD;YACE,MAAM,EAAE,QAAQ;YAChB,OAAO,EAAE,uCAAuC;SACjD;KACF;IACD,OAAO,EAAE;QACP,kCAAkC;QAClC,iCAAiC;QACjC,0BAA0B;QAC1B,4BAA4B;QAC5B,wBAAwB;KACzB;IACD,SAAS,EAAE;QACT,sCAAsC;QACtC,kBAAkB;QAClB,wBAAwB;KACzB;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,IAAI,EAAE,mBAAmB;IACzB,WAAW,EAAE,6MAA6M;IAC1N,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wQAwE8P;IACtQ,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IACxD,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,iCAAiC;CAC5C,CAAC"}

package/dist/agents/index.d.ts

@@ -1,5 +1,21 @@
 /**
  * Agents Module Exports
+ *
+ * New modular agent system with individual files and metadata.
+ * Maintains backward compatibility with definitions.ts exports.
  */
-export { oracleAgent, librarianAgent, exploreAgent, frontendEngineerAgent, documentWriterAgent, multimodalLookerAgent, getAgentDefinitions, sisyphusSystemPrompt } from './definitions.js';
+export * from './types.js';
+export { createAgentToolRestrictions, mergeAgentConfig, buildDelegationTable, buildUseAvoidSection, createEnvContext, getAvailableAgents, buildKeyTriggersSection, validateAgentConfig, deepMerge } from './utils.js';
+export { oracleAgent, ORACLE_PROMPT_METADATA } from './oracle.js';
+export { exploreAgent, EXPLORE_PROMPT_METADATA } from './explore.js';
+export { librarianAgent, LIBRARIAN_PROMPT_METADATA } from './librarian.js';
+export { sisyphusJuniorAgent, SISYPHUS_JUNIOR_PROMPT_METADATA } from './sisyphus-junior.js';
+export { frontendEngineerAgent, FRONTEND_ENGINEER_PROMPT_METADATA } from './frontend-engineer.js';
+export { documentWriterAgent, DOCUMENT_WRITER_PROMPT_METADATA } from './document-writer.js';
+export { multimodalLookerAgent, MULTIMODAL_LOOKER_PROMPT_METADATA } from './multimodal-looker.js';
+export { momusAgent, MOMUS_PROMPT_METADATA } from './momus.js';
+export { metisAgent, METIS_PROMPT_METADATA } from './metis.js';
+export { orchestratorSisyphusAgent, ORCHESTRATOR_SISYPHUS_PROMPT_METADATA } from './orchestrator-sisyphus.js';
+export { prometheusAgent, PROMETHEUS_PROMPT_METADATA } from './prometheus.js';
+export { getAgentDefinitions, sisyphusSystemPrompt } from './definitions.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/agents/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,qCAAqC,EAAE,MAAM,4BAA4B,CAAC;AAC9G,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC"}

package/dist/agents/index.js

@@ -1,5 +1,25 @@
 /**
  * Agents Module Exports
+ *
+ * New modular agent system with individual files and metadata.
+ * Maintains backward compatibility with definitions.ts exports.
  */
-export { oracleAgent, librarianAgent, exploreAgent, frontendEngineerAgent, documentWriterAgent, multimodalLookerAgent, getAgentDefinitions, sisyphusSystemPrompt } from './definitions.js';
+// Types
+export * from './types.js';
+// Utilities
+export { createAgentToolRestrictions, mergeAgentConfig, buildDelegationTable, buildUseAvoidSection, createEnvContext, getAvailableAgents, buildKeyTriggersSection, validateAgentConfig, deepMerge } from './utils.js';
+// Individual agent exports (new modular structure)
+export { oracleAgent, ORACLE_PROMPT_METADATA } from './oracle.js';
+export { exploreAgent, EXPLORE_PROMPT_METADATA } from './explore.js';
+export { librarianAgent, LIBRARIAN_PROMPT_METADATA } from './librarian.js';
+export { sisyphusJuniorAgent, SISYPHUS_JUNIOR_PROMPT_METADATA } from './sisyphus-junior.js';
+export { frontendEngineerAgent, FRONTEND_ENGINEER_PROMPT_METADATA } from './frontend-engineer.js';
+export { documentWriterAgent, DOCUMENT_WRITER_PROMPT_METADATA } from './document-writer.js';
+export { multimodalLookerAgent, MULTIMODAL_LOOKER_PROMPT_METADATA } from './multimodal-looker.js';
+export { momusAgent, MOMUS_PROMPT_METADATA } from './momus.js';
+export { metisAgent, METIS_PROMPT_METADATA } from './metis.js';
+export { orchestratorSisyphusAgent, ORCHESTRATOR_SISYPHUS_PROMPT_METADATA } from './orchestrator-sisyphus.js';
+export { prometheusAgent, PROMETHEUS_PROMPT_METADATA } from './prometheus.js';
+// Legacy exports (backward compatibility - getAgentDefinitions and sisyphusSystemPrompt)
+export { getAgentDefinitions, sisyphusSystemPrompt } from './definitions.js';
 //# sourceMappingURL=index.js.map

package/dist/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,QAAQ;AACR,cAAc,YAAY,CAAC;AAE3B,YAAY;AACZ,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,qCAAqC,EAAE,MAAM,4BAA4B,CAAC;AAC9G,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAE9E,yFAAyF;AACzF,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC"}

package/dist/agents/librarian.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Librarian Agent - Documentation and External Reference Finder
+ *
+ * Searches external resources: official docs, GitHub, Stack Overflow.
+ * For internal codebase searches, use explore agent instead.
+ *
+ * Ported from oh-my-opencode's librarian agent.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const LIBRARIAN_PROMPT_METADATA: AgentPromptMetadata;
+export declare const librarianAgent: AgentConfig;
+//# sourceMappingURL=librarian.d.ts.map

package/dist/agents/librarian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"librarian.d.ts","sourceRoot":"","sources":["../../src/agents/librarian.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,yBAAyB,EAAE,mBAqBvC,CAAC;AAmEF,eAAO,MAAM,cAAc,EAAE,WAO5B,CAAC"}