opencode-deepa 1.0.0

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "opencode-deepa",
+  "version": "1.0.0",
+  "description": "DeepA - Orchestrator-like agent plugin for OpenCode that delegates tasks to specialist agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "opencode-deepa": "./dist/cli/index.js"
+  },
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "agents",
+    "orchestration",
+    "llm"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/opencode-deepa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/opencode-deepa/issues"
+  },
+  "homepage": "https://github.com/yourusername/opencode-deepa#readme",
+  "files": [
+    "dist",
+    "src/skills",
+    "opencode-deepa.schema.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && tsc --emitDeclarationOnly && bun run generate-schema",
+    "generate-schema": "bun run scripts/generate-schema.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check --write .",
+    "check:ci": "biome check .",
+    "dev": "bun run build && opencode",
+    "prepublishOnly": "bun run build",
+    "release:patch": "npm version patch && git push --follow-tags && npm publish",
+    "release:minor": "npm version minor && git push --follow-tags && npm publish",
+    "release:major": "npm version major && git push --follow-tags && npm publish"
+  },
+  "dependencies": {
+    "@ast-grep/cli": "^0.40.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@opencode-ai/plugin": "^1.2.6",
+    "@opencode-ai/sdk": "^1.2.6",
+    "vscode-jsonrpc": "^8.2.0",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.2",
+    "@types/bun": "^1.3.10",
+    "bun-types": "1.3.9",
+    "typescript": "^5.9.3"
+  },
+  "trustedDependencies": [
+    "@ast-grep/cli"
+  ]
+}

package/src/skills/deepa-planning/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: deepa-planning
+description: Strategic planning and task decomposition for complex coding tasks
+---
+
+# DeepA Planning Skill
+
+You help users break down complex coding tasks into manageable, executable steps with clear delegation to specialist agents.
+
+## When to Use
+
+- User presents a high-level goal that requires multiple steps
+- Task involves architectural decisions or coordination between different parts of the codebase
+- User needs a structured plan before implementation begins
+- Complex task that would benefit from parallel execution by specialist agents
+
+## Workflow
+
+### Step 1: Understand the Goal
+
+1. **Parse the user's request** - Identify explicit requirements and implicit needs
+2. **Ask clarifying questions** - Use the `ask-questions-if-underspecified` skill if the goal is vague or has multiple interpretations
+3. **Determine success criteria** - Define what "done" looks like for this task
+
+### Step 2: Analyze the Codebase
+
+1. **Delegate to @explorer** - Discover relevant files, patterns, and existing implementations
+2. **Delegate to @librarian** - Check for relevant library documentation or API references
+3. **Review existing code** - Understand current structure, conventions, and potential integration points
+
+### Step 3: Create the Plan
+
+1. **Break down into tasks** - Divide the goal into bite-sized, independent tasks (ideal size: 20-60 minutes each)
+2. **Identify dependencies** - Determine which tasks must be sequential vs. which can run in parallel
+3. **Assign specialist agents** - For each task, determine the optimal agent (@fixer for implementation, @designer for UI, etc.)
+4. **Define deliverables** - Specify what each task should produce (code changes, documentation, tests, etc.)
+
+### Step 4: Present the Plan
+
+1. **Show the task breakdown** - List each task with estimated effort and assigned agent
+2. **Highlight parallelization opportunities** - Show which tasks can run simultaneously
+3. **Request approval** - Ask the user to confirm or adjust the plan before execution
+
+### Step 5: Execute and Monitor
+
+1. **Fire parallel research/implementation** - Delegate to specialists based on the plan
+2. **Integrate results** - Combine outputs from specialist agents
+3. **Verify completion** - Run `lsp_diagnostics` and confirm solution meets requirements
+4. **Suggest simplification** - Recommend the `simplify` skill when applicable
+
+## Task Format
+
+Each task should include:
+- **ID**: Unique identifier (e.g., TASK-001)
+- **Description**: Clear, concise statement of what needs to be done
+- **Estimated Effort**: Time range (e.g., "20-40 minutes")
+- **Primary Agent**: @fixer, @designer, @explorer, @librarian, or @oracle
+- **Dependencies**: List of task IDs that must complete first
+- **Deliverables**: Specific outputs expected (files to modify, tests to write, etc.)
+
+## Example Plan
+
+For a request like "Add user authentication to the web app":
+
+```
+TASK-001: Design authentication flow
+  - Effort: 15-25 minutes
+  - Agent: @oracle
+  - Dependencies: None
+  - Deliverables: Authentication sequence diagram, token storage decision
+
+TASK-002: Implement auth service
+  - Effort: 30-50 minutes
+  - Agent: @fixer
+  - Dependencies: TASK-001
+  - Deliverables: AuthService class with login/logout/token refresh methods
+
+TASK-003: Create login/logout UI components
+  - Effort: 25-40 minutes
+  - Agent: @designer
+  - Dependencies: TASK-001
+  - Deliverables: LoginForm and LogoutButton components
+
+TASK-004: Protect API routes
+  - Effort: 20-30 minutes
+  - Agent: @fixer
+  - Dependencies: TASK-002
+  - Deliverables: Middleware to validate tokens on protected routes
+
+TASK-005: Add authentication tests
+  - Effort: 20-30 minutes
+  - Agent: @fixer
+  - Dependencies: TASK-002, TASK-003, TASK-004
+  - Deliverables: Unit and integration tests for auth flow
+```
+
+Tasks 002 and 003 can run in parallel after TASK-001 completes.
+Tasks 004 depends on TASK-002, and TASK-005 depends on all previous tasks.

package/src/skills/index.ts

@@ -0,0 +1,142 @@
+/**
+ * A recommended skill to install via `npx skills add`.
+ */
+export interface RecommendedSkill {
+  /** Human-readable name for prompts */
+  name: string;
+  /** GitHub repo URL for `npx skills add` */
+  repo: string;
+  /** Skill name within the repo (--skill flag) */
+  skillName: string;
+  /** List of agents that should auto-allow this skill */
+  allowedAgents: string[];
+  /** Description shown to user during install */
+  description: string;
+  /** Optional commands to run after the skill is added */
+  postInstallCommands?: string[];
+}
+
+/**
+ * List of recommended skills.
+ * Add new skills here to include them in the installation flow.
+ */
+export const RECOMMENDED_SKILLS: RecommendedSkill[] = [
+  {
+    name: 'simplify',
+    repo: 'https://github.com/brianlovin/claude-config',
+    skillName: 'simplify',
+    allowedAgents: ['deepa', 'deepa-builder'],
+    description: 'YAGNI code simplification expert',
+  },
+  {
+    name: 'agent-browser',
+    repo: 'https://github.com/vercel-labs/agent-browser',
+    skillName: 'agent-browser',
+    allowedAgents: ['deepa', 'deepa-planner', 'deepa-builder'],
+    description: 'High-performance browser automation',
+    postInstallCommands: [
+      'npm install -g agent-browser',
+      'agent-browser install',
+    ],
+  },
+  {
+    name: 'ask-questions-if-underspecified',
+    repo: 'https://github.com/smartfrog/opencode-froggy',
+    skillName: 'ask-questions-if-underspecified',
+    allowedAgents: ['deepa', 'deepa-planner', 'deepa-builder'],
+    description: 'Clarify requirements before implementing. Use when serious doubts arise.',
+  },
+];
+
+/**
+ * Install a skill using `npx skills add`.
+ * @param skill - The skill to install
+ * @returns True if installation succeeded, false otherwise
+ */
+export function installSkill(skill: RecommendedSkill): boolean {
+  // This would normally use bun.spawnSync but we'll simplify for now
+  // In a real implementation, this would call the skills CLI
+  console.log(`Would install skill: ${skill.name} from ${skill.repo}`);
+  return true;
+}
+
+/**
+ * A skill that is managed externally (e.g. user-installed) and needs
+ * permission grants but is NOT installed by this plugin's CLI.
+ */
+export interface PermissionOnlySkill {
+  /** Skill name — must match the name OpenCode uses for permission checks */
+  name: string;
+  /** List of agents that should auto-allow this skill */
+  allowedAgents: string[];
+  /** Human-readable description (for documentation only) */
+  description: string;
+}
+
+/**
+ * Skills managed externally (not installed by this plugin's CLI).
+ * Entries here only affect agent permission grants — nothing is installed.
+ */
+export const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[] = [
+  {
+    name: 'git-check',
+    allowedAgents: ['deepa', 'deepa-planner', 'deepa-builder'],
+    description: 'Check and configure git user name and email, and provide push/commit capabilities.',
+  },
+];
+
+/**
+ * Get permission presets for a specific agent based on recommended skills.
+ * @param agentName - The name of the agent
+ * @param skillList - Optional explicit list of skills to allow (overrides recommendations)
+ * @returns Permission rules for the skill permission type
+ */
+export function getSkillPermissionsForAgent(
+  agentName: string,
+  skillList?: string[],
+): Record<string, 'allow' | 'ask' | 'deny'> {
+  // Orchestrator gets all skills by default, others are restricted
+  const permissions: Record<string, 'allow' | 'ask' | 'deny'> = {
+    '*': agentName === 'deepa' ? 'allow' : 'deny',
+  };
+
+  // If the user provided an explicit skill list (even empty), honor it
+  if (skillList) {
+    permissions['*'] = 'deny';
+    for (const name of skillList) {
+      if (name === '*') {
+        permissions['*'] = 'allow';
+      } else if (name.startsWith('!')) {
+        permissions[name.slice(1)] = 'deny';
+      } else {
+        permissions[name] = 'allow';
+      }
+    }
+    return permissions;
+  }
+
+  // Otherwise, use recommended defaults
+  for (const skill of RECOMMENDED_SKILLS) {
+    const isAllowed =
+      skill.allowedAgents.includes('*') ||
+      skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.skillName] = 'allow';
+    }
+  }
+
+  // Apply permissions from bundled custom skills
+  // (none currently)
+
+  // Apply permissions for externally-managed skills (not installed by this plugin)
+  for (const skill of PERMISSION_ONLY_SKILLS) {
+    const isAllowed =
+      skill.allowedAgents.includes('*') ||
+      skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.name] = 'allow';
+    }
+  }
+
+  return permissions;
+}