@agentuity/opencode 1.0.1 → 1.0.3

package/dist/tools/delegate.js

@@ -1,72 +0,0 @@
-import { z } from 'zod';
-// Schema for the delegate tool
-export const DelegateArgsSchema = z.object({
-    agent: z
-        .enum([
-        'scout',
-        'builder',
-        'architect',
-        'reviewer',
-        'memory',
-        'reasoner',
-        'expert',
-        'planner',
-        'runner',
-        'product',
-    ])
-        .describe('The agent to delegate to'),
-    task: z.string().describe('Clear description of the task to delegate'),
-    context: z.string().optional().describe('Additional context from previous tasks'),
-    waitForResult: z
-        .boolean()
-        .default(true)
-        .describe('Whether to wait for the result before continuing'),
-});
-// Agent display names for @mentions
-const AGENT_MENTIONS = {
-    lead: '@Agentuity Coder Lead',
-    scout: '@Agentuity Coder Scout',
-    builder: '@Agentuity Coder Builder',
-    architect: '@Agentuity Coder Architect',
-    reviewer: '@Agentuity Coder Reviewer',
-    memory: '@Agentuity Coder Memory',
-    expert: '@Agentuity Coder Expert',
-    planner: '@Agentuity Coder Planner',
-    runner: '@Agentuity Coder Runner',
-    reasoner: '@Agentuity Coder Reasoner',
-    product: '@Agentuity Coder Product',
-};
-export const delegateTool = {
-    name: 'agentuity_coder_delegate',
-    description: `Delegate a task to a specialized Agentuity Coder agent.
-
-Use this to:
-- Scout: Explore codebase, find patterns, research documentation
-- Builder: Implement features, write code, run tests (interactive work)
-- Architect: Complex autonomous tasks, Cadence mode, deep reasoning (GPT Codex)
-- Reviewer: Review changes, catch issues, apply fixes
-- Memory: Store context, remember decisions across sessions
-- Reasoner: Extract structured conclusions, resolve conflicts, surface corrections
-- Expert: Get help with Agentuity CLI and cloud services
-- Planner: Strategic advisor for complex architecture and deep planning (read-only)
-- Runner: Run lint/build/test/typecheck/format/clean/install commands, returns structured results
-- Product: Drive clarity on requirements, validate features, track progress, Cadence briefings
-
-The task will be executed by the specified agent and the result returned.`,
-    args: DelegateArgsSchema,
-    async execute(args, _context) {
-        const mention = AGENT_MENTIONS[args.agent];
-        // Build the delegation prompt
-        let prompt = `${mention}\n\n## Task\n${args.task}`;
-        if (args.context) {
-            prompt = `${mention}\n\n## Context\n${args.context}\n\n## Task\n${args.task}`;
-        }
-        // In Open Code, this would trigger the Task tool with the appropriate agent
-        // For now, return the formatted prompt that Lead should use
-        return {
-            output: `To delegate this task, use the Task tool with this prompt:\n\n${prompt}\n\nThe ${args.agent} agent will handle this task.`,
-        };
-    },
-};
-export default delegateTool;
-//# sourceMappingURL=delegate.js.map

package/dist/tools/delegate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"delegate.js","sourceRoot":"","sources":["../../src/tools/delegate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,+BAA+B;AAC/B,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC;SACN,IAAI,CAAC;QACL,OAAO;QACP,SAAS;QACT,WAAW;QACX,UAAU;QACV,QAAQ;QACR,UAAU;QACV,QAAQ;QACR,SAAS;QACT,QAAQ;QACR,SAAS;KACT,CAAC;SACD,QAAQ,CAAC,0BAA0B,CAAC;IACtC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACtE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IACjF,aAAa,EAAE,CAAC;SACd,OAAO,EAAE;SACT,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC,kDAAkD,CAAC;CAC9D,CAAC,CAAC;AAIH,oCAAoC;AACpC,MAAM,cAAc,GAA8B;IACjD,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,wBAAwB;IAC/B,OAAO,EAAE,0BAA0B;IACnC,SAAS,EAAE,4BAA4B;IACvC,QAAQ,EAAE,2BAA2B;IACrC,MAAM,EAAE,yBAAyB;IACjC,MAAM,EAAE,yBAAyB;IACjC,OAAO,EAAE,0BAA0B;IACnC,MAAM,EAAE,yBAAyB;IACjC,QAAQ,EAAE,2BAA2B;IACrC,OAAO,EAAE,0BAA0B;CACnC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC3B,IAAI,EAAE,0BAA0B;IAChC,WAAW,EAAE;;;;;;;;;;;;;;0EAc4D;IAEzE,IAAI,EAAE,kBAAkB;IAExB,KAAK,CAAC,OAAO,CAAC,IAAkB,EAAE,QAAiB;QAClD,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,KAAkB,CAAC,CAAC;QAExD,8BAA8B;QAC9B,IAAI,MAAM,GAAG,GAAG,OAAO,gBAAgB,IAAI,CAAC,IAAI,EAAE,CAAC;QAEnD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,GAAG,GAAG,OAAO,mBAAmB,IAAI,CAAC,OAAO,gBAAgB,IAAI,CAAC,IAAI,EAAE,CAAC;QAC/E,CAAC;QAED,4EAA4E;QAC5E,4DAA4D;QAC5D,OAAO;YACN,MAAM,EAAE,iEAAiE,MAAM,WAAW,IAAI,CAAC,KAAK,+BAA+B;SACnI,CAAC;IACH,CAAC;CACD,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/src/agents/planner.ts

@@ -1,161 +0,0 @@
-import type { AgentDefinition } from './types';
-
-export const PLANNER_SYSTEM_PROMPT = `# Planner Agent
-
-You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within the Agentuity Coder team.
-
-## Context
-
-You function as an on-demand specialist invoked by the Lead agent when complex analysis or architectural decisions require elevated reasoning. Each consultation is standalone—treat every request as complete and self-contained since no clarifying dialogue is possible.
-
-## What You ARE / ARE NOT
-
-| You ARE | You ARE NOT |
-|---------|-------------|
-| Strategic technical advisor | Code implementer |
-| Architecture analyst | Direct file editor |
-| Deep reasoning specialist | Quick task executor |
-| Decision framework provider | Build/test runner |
-| Risk assessor | Project manager |
-
-## What You Do
-
-Your expertise covers:
-- Dissecting codebases to understand structural patterns and design choices
-- Formulating concrete, implementable technical recommendations
-- Architecting solutions and mapping out implementation roadmaps
-- Resolving intricate technical questions through systematic reasoning
-- Surfacing hidden issues and crafting preventive measures
-- Creating detailed, actionable plans that Builder can execute
-
-## Decision Framework
-
-Apply pragmatic minimalism in all recommendations:
-
-**Bias toward simplicity**: The right solution is typically the least complex one that fulfills the actual requirements. Resist hypothetical future needs.
-
-**Leverage what exists**: Favor modifications to current code, established patterns, and existing dependencies over introducing new components. New libraries, services, or infrastructure require explicit justification.
-
-**Prioritize developer experience**: Optimize for readability, maintainability, and reduced cognitive load. Theoretical performance gains or architectural purity matter less than practical usability.
-
-**One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different trade-offs worth considering.
-
-**Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems or explicit requests for depth.
-
-**Signal the investment**: Tag recommendations with estimated effort—use Quick(<1h), Short(1-4h), Medium(1-2d), or Large(3d+) to set expectations.
-
-**Know when to stop**: "Working well" beats "theoretically optimal." Identify what conditions would warrant revisiting with a more sophisticated approach.
-
-## Working With Tools
-
-You are a **read-only** agent. You can:
-- Read files to understand code structure
-- Use glob/grep to find patterns
-- Fetch documentation
-
-You **cannot** and **should not**:
-- Write or edit files
-- Run bash commands
-- Execute tests or builds
-- Make any modifications
-
-Your role is to analyze and recommend. Builder will execute your plans.
-
-## Response Structure
-
-Organize your final answer in three tiers:
-
-### Essential (always include)
-
-**Bottom Line**: 2-3 sentences capturing your recommendation
-
-**Action Plan**: Numbered steps or checklist for implementation
-- Each step should be specific enough for Builder to execute
-- Include file paths, function names, and expected changes
-- Order steps by dependency (what must happen first)
-
-**Effort Estimate**: Using the Quick/Short/Medium/Large scale
-
-### Expanded (include when relevant)
-
-**Why This Approach**: Brief reasoning and key trade-offs considered
-
-**Watch Out For**: Risks, edge cases, and mitigation strategies
-
-**Dependencies**: What needs to exist before this work can begin
-
-### Edge Cases (only when genuinely applicable)
-
-**Escalation Triggers**: Specific conditions that would justify a more complex solution
-
-**Alternative Sketch**: High-level outline of the advanced path (not a full design)
-
-## Plan Format for Builder
-
-When creating implementation plans, use this structure:
-
-\`\`\`markdown
-## Implementation Plan
-
-### Phase 1: [Name]
-**Effort**: Quick/Short/Medium/Large
-
-1. **[Step Name]**
-   - File: \`path/to/file.ts\`
-   - Action: [Create/Modify/Delete]
-   - Details: [Specific changes needed]
-
-2. **[Step Name]**
-   - File: \`path/to/other.ts\`
-   - Action: [Create/Modify/Delete]
-   - Details: [Specific changes needed]
-
-### Phase 2: [Name]
-...
-
-### Verification
-- [ ] [Specific test or check]
-- [ ] [Another verification step]
-\`\`\`
-
-## Guiding Principles
-
-- **Actionable insight over exhaustive analysis**: Give Builder what they need to execute
-- **Depth matches complexity**: Simple questions get simple answers
-- **One recommendation**: Present the best path, not all possible paths
-- **Concrete specifics**: File paths, function names, exact changes
-- **Risk awareness**: Surface potential issues before they become problems
-
-## Collaboration
-
-You work primarily with Lead and Builder/Architect:
-
-| Agent | How You Help Them |
-|-------|-------------------|
-| Lead | Provide strategic analysis, architecture decisions, detailed plans |
-| Builder or Architect | Create step-by-step implementation plans they can execute |
-| Reviewer | Offer architectural context for code reviews |
-| Scout | N/A (Scout gathers info for you to analyze) |
-
-## Critical Note
-
-Your response goes directly to the Lead agent who will delegate to Builder. Make your final message self-contained: a clear recommendation and actionable plan that Builder can execute immediately.
-
-**You are read-only.** Analyze, recommend, and plan—but never attempt to modify code yourself.
-`;
-
-export const plannerAgent: AgentDefinition = {
-	role: 'planner',
-	id: 'ag-planner',
-	displayName: 'Agentuity Coder Planner',
-	description:
-		'Strategic technical advisor for complex architecture and deep planning. Read-only, high-reasoning specialist.',
-	defaultModel: 'openai/gpt-5.2',
-	systemPrompt: PLANNER_SYSTEM_PROMPT,
-	mode: 'subagent',
-	tools: {
-		exclude: ['write', 'edit', 'apply_patch', 'bash'], // Read-only agent
-	},
-	reasoningEffort: 'xhigh', // Maximum reasoning for GPT models
-	temperature: 0.1, // Low for consistent, deterministic analysis
-};

package/src/tools/delegate.ts

@@ -1,83 +0,0 @@
-import { z } from 'zod';
-import type { AgentRole } from '../types';
-
-// Schema for the delegate tool
-export const DelegateArgsSchema = z.object({
-	agent: z
-		.enum([
-			'scout',
-			'builder',
-			'architect',
-			'reviewer',
-			'memory',
-			'reasoner',
-			'expert',
-			'planner',
-			'runner',
-			'product',
-		])
-		.describe('The agent to delegate to'),
-	task: z.string().describe('Clear description of the task to delegate'),
-	context: z.string().optional().describe('Additional context from previous tasks'),
-	waitForResult: z
-		.boolean()
-		.default(true)
-		.describe('Whether to wait for the result before continuing'),
-});
-
-export type DelegateArgs = z.infer<typeof DelegateArgsSchema>;
-
-// Agent display names for @mentions
-const AGENT_MENTIONS: Record<AgentRole, string> = {
-	lead: '@Agentuity Coder Lead',
-	scout: '@Agentuity Coder Scout',
-	builder: '@Agentuity Coder Builder',
-	architect: '@Agentuity Coder Architect',
-	reviewer: '@Agentuity Coder Reviewer',
-	memory: '@Agentuity Coder Memory',
-	expert: '@Agentuity Coder Expert',
-	planner: '@Agentuity Coder Planner',
-	runner: '@Agentuity Coder Runner',
-	reasoner: '@Agentuity Coder Reasoner',
-	product: '@Agentuity Coder Product',
-};
-
-export const delegateTool = {
-	name: 'agentuity_coder_delegate',
-	description: `Delegate a task to a specialized Agentuity Coder agent.
-
-Use this to:
-- Scout: Explore codebase, find patterns, research documentation
-- Builder: Implement features, write code, run tests (interactive work)
-- Architect: Complex autonomous tasks, Cadence mode, deep reasoning (GPT Codex)
-- Reviewer: Review changes, catch issues, apply fixes
-- Memory: Store context, remember decisions across sessions
-- Reasoner: Extract structured conclusions, resolve conflicts, surface corrections
-- Expert: Get help with Agentuity CLI and cloud services
-- Planner: Strategic advisor for complex architecture and deep planning (read-only)
-- Runner: Run lint/build/test/typecheck/format/clean/install commands, returns structured results
-- Product: Drive clarity on requirements, validate features, track progress, Cadence briefings
-
-The task will be executed by the specified agent and the result returned.`,
-
-	args: DelegateArgsSchema,
-
-	async execute(args: DelegateArgs, _context: unknown): Promise<{ output: string }> {
-		const mention = AGENT_MENTIONS[args.agent as AgentRole];
-
-		// Build the delegation prompt
-		let prompt = `${mention}\n\n## Task\n${args.task}`;
-
-		if (args.context) {
-			prompt = `${mention}\n\n## Context\n${args.context}\n\n## Task\n${args.task}`;
-		}
-
-		// In Open Code, this would trigger the Task tool with the appropriate agent
-		// For now, return the formatted prompt that Lead should use
-		return {
-			output: `To delegate this task, use the Task tool with this prompt:\n\n${prompt}\n\nThe ${args.agent} agent will handle this task.`,
-		};
-	},
-};
-
-export default delegateTool;