opencode-mad 0.4.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mad",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "Multi-Agent Dev - Parallel development orchestration plugin for OpenCode",
   "type": "module",
   "main": "plugins/mad-plugin.ts",

package/plugins/mad-plugin.ts

@@ -12,8 +12,39 @@ import { execSync } from "child_process"
  * running in parallel via OpenCode's Task tool.
  */
 
+// Types for agent permissions (constraint enforcement)
+interface AgentPermissions {
+  type: 'orchestrator' | 'analyste' | 'architecte' | 'developer' | 'tester' | 'reviewer' | 'fixer' | 'merger' | 'security'
+  canEdit: boolean
+  canWrite: boolean
+  canPatch: boolean
+  allowedPaths: string[] | null  // null = all, [] = none, [...] = specific list
+  deniedPaths: string[]          // Explicitly denied paths
+  worktree: string | null        // Worktree path if applicable
+}
+
+// Global map to store permissions by sessionID
+const agentPermissions = new Map<string, AgentPermissions>()
+
+// Simple glob matching (for patterns like /backend/**)
+function matchGlob(path: string, pattern: string): boolean {
+  // Normalize paths
+  const normalizedPath = path.replace(/\\/g, '/')
+  const normalizedPattern = pattern.replace(/\\/g, '/')
+  
+  // Convert glob to regex
+  const regexPattern = normalizedPattern
+    .replace(/\*\*/g, '{{DOUBLESTAR}}')
+    .replace(/\*/g, '[^/]*')
+    .replace(/{{DOUBLESTAR}}/g, '.*')
+    .replace(/\//g, '\\/')
+  
+  const regex = new RegExp(`^${regexPattern}$`)
+  return regex.test(normalizedPath)
+}
+
 // Current version of opencode-mad
-const CURRENT_VERSION = "0.4.0"
+const CURRENT_VERSION = "1.0.0"
 
 // Update notification state (shown only once per session)
 let updateNotificationShown = false
@@ -21,6 +52,9 @@ let pendingUpdateMessage: string | null = null
 
 export const MADPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
   
+  // Use the directory provided by OpenCode, fallback to process.cwd() for backwards compatibility
+  const baseDirectory = directory || process.cwd()
+  
   /**
    * Helper to run shell commands with proper error handling (cross-platform)
    */
@@ -28,7 +62,7 @@ export const MADPlugin: Plugin = async ({ project, client, $, directory, worktre
     try {
       const output = execSync(cmd, { 
         encoding: "utf-8", 
-        cwd: cwd || process.cwd(),
+        cwd: cwd || baseDirectory,
         stdio: ["pipe", "pipe", "pipe"]
       })
       return { success: true, output: output.trim() }
@@ -43,9 +77,10 @@ export const MADPlugin: Plugin = async ({ project, client, $, directory, worktre
 
   /**
    * Helper to get git root with error handling
+   * @param basePath - Optional base path to start from (defaults to baseDirectory)
    */
-  const getGitRoot = (): string => {
-    const result = runCommand("git rev-parse --show-toplevel")
+  const getGitRoot = (basePath?: string): string => {
+    const result = runCommand("git rev-parse --show-toplevel", basePath || baseDirectory)
     if (!result.success) {
       throw new Error(`Not a git repository or git not found: ${result.error}`)
     }
@@ -54,18 +89,20 @@ export const MADPlugin: Plugin = async ({ project, client, $, directory, worktre
 
   /**
    * Helper to get current branch with fallback
+   * @param basePath - Optional base path to run git command from (defaults to baseDirectory)
    */
-  const getCurrentBranch = (): string => {
-    const result = runCommand("git symbolic-ref --short HEAD")
+  const getCurrentBranch = (basePath?: string): string => {
+    const result = runCommand("git symbolic-ref --short HEAD", basePath || baseDirectory)
     return result.success ? result.output : "main"
   }
 
   /**
    * Helper to log MAD events
+   * Uses baseDirectory to find the git root for log file location
    */
   const logEvent = (level: "info" | "warn" | "error" | "debug", message: string, context?: any) => {
     try {
-      const gitRoot = getGitRoot()
+      const gitRoot = getGitRoot(baseDirectory)
       const logFile = join(gitRoot, ".mad-logs.jsonl")
       const logEntry = JSON.stringify({
         timestamp: new Date().toISOString(),
@@ -1111,6 +1148,306 @@ Use this at the end of the MAD workflow to ensure code quality.`,
           }
         },
       }),
+
+      /**
+       * Register agent permissions for constraint enforcement
+       */
+      mad_register_agent: tool({
+        description: `Register an agent's permissions for constraint enforcement.
+Call this when spawning a subagent to define what it can and cannot do.
+The plugin will then BLOCK any unauthorized actions.`,
+        args: {
+          sessionID: tool.schema.string().describe("The session ID of the agent"),
+          agentType: tool.schema.enum([
+            'orchestrator', 'analyste', 'architecte', 'developer', 
+            'tester', 'reviewer', 'fixer', 'merger', 'security'
+          ]).describe("Type of agent"),
+          worktree: tool.schema.string().optional().describe("Worktree path if applicable"),
+          allowedPaths: tool.schema.array(tool.schema.string()).optional().describe("Paths the agent can edit (glob patterns)"),
+          deniedPaths: tool.schema.array(tool.schema.string()).optional().describe("Paths explicitly denied"),
+        },
+        async execute(args, context) {
+          const { sessionID, agentType, worktree, allowedPaths, deniedPaths } = args
+          
+          // Define default permissions based on agent type
+          const readOnlyAgents = ['orchestrator', 'analyste', 'architecte', 'tester', 'reviewer', 'security']
+          const canEdit = !readOnlyAgents.includes(agentType)
+          
+          const permissions: AgentPermissions = {
+            type: agentType,
+            canEdit,
+            canWrite: canEdit,
+            canPatch: canEdit,
+            allowedPaths: allowedPaths || null,
+            deniedPaths: deniedPaths || [],
+            worktree: worktree || null,
+          }
+          
+          agentPermissions.set(sessionID, permissions)
+          
+          logEvent("info", `Registered agent permissions`, { sessionID, agentType, canEdit, worktree })
+          
+          return getUpdateNotification() + `✅ Agent registered: ${agentType} (canEdit: ${canEdit}, worktree: ${worktree || 'none'})`
+        }
+      }),
+
+      /**
+       * Analyze codebase - for Analyst agent
+       */
+      mad_analyze: tool({
+        description: `Trigger a codebase analysis. Returns a structured report.
+Use mode 'full' for complete project scan, 'targeted' for task-specific analysis.`,
+        args: {
+          mode: tool.schema.enum(['full', 'targeted']).describe("Analysis mode"),
+          focus: tool.schema.string().optional().describe("For targeted mode: what to focus on"),
+          paths: tool.schema.array(tool.schema.string()).optional().describe("Specific paths to analyze"),
+        },
+        async execute(args, context) {
+          const { mode, focus, paths } = args
+          const gitRoot = getGitRoot()
+          
+          let report = `# Codebase Analysis Report\n\n`
+          report += `**Mode:** ${mode}\n`
+          report += `**Date:** ${new Date().toISOString()}\n\n`
+          
+          // Collecter les informations de base
+          const structure = runCommand('find . -type f -name "*.ts" -o -name "*.js" -o -name "*.json" | grep -v node_modules | head -50', gitRoot)
+          const packageJsonPath = join(gitRoot, 'package.json')
+          const packageJson = existsSync(packageJsonPath) 
+            ? JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+            : null
+          
+          report += `## Project Structure\n\`\`\`\n${structure.output}\n\`\`\`\n\n`
+          
+          if (packageJson) {
+            report += `## Dependencies\n`
+            report += `- **Name:** ${packageJson.name}\n`
+            report += `- **Version:** ${packageJson.version}\n`
+            report += `- **Dependencies:** ${Object.keys(packageJson.dependencies || {}).length}\n`
+            report += `- **DevDependencies:** ${Object.keys(packageJson.devDependencies || {}).length}\n\n`
+          }
+          
+          if (mode === 'targeted' && focus) {
+            report += `## Targeted Analysis: ${focus}\n`
+            // Chercher les fichiers pertinents
+            const relevantFiles = runCommand(`grep -rl "${focus}" --include="*.ts" --include="*.js" . | grep -v node_modules | head -20`, gitRoot)
+            report += `### Relevant Files\n\`\`\`\n${relevantFiles.output || 'No files found'}\n\`\`\`\n`
+          }
+          
+          logEvent("info", "Codebase analysis completed", { mode, focus })
+          return getUpdateNotification() + report
+        }
+      }),
+
+      /**
+       * Unregister agent permissions when it completes
+       */
+      mad_unregister_agent: tool({
+        description: `Unregister an agent's permissions when it completes.`,
+        args: {
+          sessionID: tool.schema.string().describe("The session ID to unregister"),
+        },
+        async execute(args) {
+          const existed = agentPermissions.has(args.sessionID)
+          agentPermissions.delete(args.sessionID)
+          
+          if (existed) {
+            logEvent("info", `Unregistered agent`, { sessionID: args.sessionID })
+            return `✅ Agent unregistered: ${args.sessionID}`
+          } else {
+            return `⚠️ Agent was not registered: ${args.sessionID}`
+          }
+        }
+      }),
+
+      /**
+       * Create development plan - for Architect agent
+       */
+      mad_create_plan: tool({
+        description: `Store a development plan created by the Architect agent.
+The plan will be available for the orchestrator to present to the user.`,
+        args: {
+          planName: tool.schema.string().describe("Name/identifier for the plan"),
+          plan: tool.schema.string().describe("The full development plan in markdown"),
+          tasks: tool.schema.array(tool.schema.object({
+            name: tool.schema.string(),
+            branch: tool.schema.string(),
+            ownership: tool.schema.array(tool.schema.string()),
+            denied: tool.schema.array(tool.schema.string()).optional(),
+            dependencies: tool.schema.array(tool.schema.string()).optional(),
+          })).describe("Structured task list"),
+        },
+        async execute(args, context) {
+          const { planName, plan, tasks } = args
+          
+          // Stocker le plan en mémoire (pourrait être persisté plus tard)
+          const planData = {
+            name: planName,
+            createdAt: new Date().toISOString(),
+            plan,
+            tasks,
+          }
+          
+          // Log pour debugging
+          logEvent("info", "Development plan created", { planName, taskCount: tasks.length })
+          
+          return getUpdateNotification() + `✅ Plan '${planName}' created with ${tasks.length} tasks.\n\n${plan}`
+        }
+      }),
+
+      /**
+       * Submit code review - for Reviewer agent
+       */
+      mad_review: tool({
+        description: `Submit a code review report for a worktree.
+Called by the Reviewer agent after analyzing the code.`,
+        args: {
+          worktree: tool.schema.string().describe("Worktree that was reviewed"),
+          verdict: tool.schema.enum(['approved', 'changes_requested', 'rejected']).describe("Review verdict"),
+          summary: tool.schema.string().describe("Brief summary of the review"),
+          issues: tool.schema.array(tool.schema.object({
+            severity: tool.schema.enum(['critical', 'major', 'minor']),
+            file: tool.schema.string(),
+            line: tool.schema.number().optional(),
+            message: tool.schema.string(),
+            suggestion: tool.schema.string().optional(),
+          })).optional().describe("List of issues found"),
+          positives: tool.schema.array(tool.schema.string()).optional().describe("Positive aspects of the code"),
+        },
+        async execute(args, context) {
+          const { worktree, verdict, summary, issues, positives } = args
+          const gitRoot = getGitRoot()
+          const worktreePath = join(gitRoot, "worktrees", worktree)
+          
+          if (!existsSync(worktreePath)) {
+            return getUpdateNotification() + `❌ Worktree not found: ${worktreePath}`
+          }
+          
+          // Créer le rapport de review
+          let report = `# Code Review: ${worktree}\n\n`
+          report += `**Verdict:** ${verdict === 'approved' ? '✅ APPROVED' : verdict === 'changes_requested' ? '⚠️ CHANGES REQUESTED' : '❌ REJECTED'}\n\n`
+          report += `## Summary\n${summary}\n\n`
+          
+          if (positives && positives.length > 0) {
+            report += `## Positives 👍\n`
+            positives.forEach(p => report += `- ${p}\n`)
+            report += '\n'
+          }
+          
+          if (issues && issues.length > 0) {
+            report += `## Issues Found\n`
+            const critical = issues.filter(i => i.severity === 'critical')
+            const major = issues.filter(i => i.severity === 'major')
+            const minor = issues.filter(i => i.severity === 'minor')
+            
+            if (critical.length > 0) {
+              report += `### 🚨 Critical (${critical.length})\n`
+              critical.forEach(i => {
+                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
+                if (i.suggestion) report += `  → Suggestion: ${i.suggestion}\n`
+              })
+            }
+            if (major.length > 0) {
+              report += `### ⚠️ Major (${major.length})\n`
+              major.forEach(i => {
+                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
+                if (i.suggestion) report += `  → Suggestion: ${i.suggestion}\n`
+              })
+            }
+            if (minor.length > 0) {
+              report += `### 💡 Minor (${minor.length})\n`
+              minor.forEach(i => {
+                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
+              })
+            }
+          }
+          
+          // Sauvegarder le rapport dans le worktree
+          writeFileSync(join(worktreePath, '.agent-review'), report)
+          
+          logEvent("info", "Code review submitted", { worktree, verdict, issueCount: issues?.length || 0 })
+          
+          return getUpdateNotification() + report
+        }
+      }),
+
+      /**
+       * Security scan - for Security agent
+       */
+      mad_security_scan: tool({
+        description: `Submit a security scan report for a worktree or the main project.
+Called by the Security agent after scanning for vulnerabilities.`,
+        args: {
+          target: tool.schema.string().describe("Worktree name or 'main' for main project"),
+          riskLevel: tool.schema.enum(['low', 'medium', 'high', 'critical']).describe("Overall risk level"),
+          summary: tool.schema.string().describe("Brief summary of findings"),
+          vulnerabilities: tool.schema.array(tool.schema.object({
+            id: tool.schema.string(),
+            severity: tool.schema.enum(['low', 'medium', 'high', 'critical']),
+            type: tool.schema.string(),
+            file: tool.schema.string().optional(),
+            line: tool.schema.number().optional(),
+            description: tool.schema.string(),
+            remediation: tool.schema.string(),
+          })).optional().describe("List of vulnerabilities found"),
+          dependencyIssues: tool.schema.array(tool.schema.object({
+            package: tool.schema.string(),
+            severity: tool.schema.string(),
+            cve: tool.schema.string().optional(),
+            fix: tool.schema.string(),
+          })).optional().describe("Vulnerable dependencies"),
+        },
+        async execute(args, context) {
+          const { target, riskLevel, summary, vulnerabilities, dependencyIssues } = args
+          const gitRoot = getGitRoot()
+          
+          let report = `# Security Scan Report: ${target}\n\n`
+          report += `**Risk Level:** ${riskLevel === 'critical' ? '🚨 CRITICAL' : riskLevel === 'high' ? '🔴 HIGH' : riskLevel === 'medium' ? '🟡 MEDIUM' : '🟢 LOW'}\n`
+          report += `**Date:** ${new Date().toISOString()}\n\n`
+          report += `## Summary\n${summary}\n\n`
+          
+          if (vulnerabilities && vulnerabilities.length > 0) {
+            report += `## Vulnerabilities (${vulnerabilities.length})\n\n`
+            vulnerabilities.forEach(v => {
+              const icon = v.severity === 'critical' ? '🚨' : v.severity === 'high' ? '🔴' : v.severity === 'medium' ? '🟡' : '🟢'
+              report += `### ${icon} [${v.id}] ${v.type}\n`
+              report += `**Severity:** ${v.severity.toUpperCase()}\n`
+              if (v.file) report += `**Location:** ${v.file}${v.line ? `:${v.line}` : ''}\n`
+              report += `**Description:** ${v.description}\n`
+              report += `**Remediation:** ${v.remediation}\n\n`
+            })
+          }
+          
+          if (dependencyIssues && dependencyIssues.length > 0) {
+            report += `## Vulnerable Dependencies (${dependencyIssues.length})\n\n`
+            report += `| Package | Severity | CVE | Fix |\n`
+            report += `|---------|----------|-----|-----|\n`
+            dependencyIssues.forEach(d => {
+              report += `| ${d.package} | ${d.severity} | ${d.cve || 'N/A'} | ${d.fix} |\n`
+            })
+            report += '\n'
+          }
+          
+          // Verdict
+          const canMerge = riskLevel === 'low' || (riskLevel === 'medium' && (!vulnerabilities || vulnerabilities.filter(v => v.severity === 'critical' || v.severity === 'high').length === 0))
+          report += `## Verdict\n`
+          report += canMerge 
+            ? `✅ **PASS** - No critical security issues blocking merge.\n`
+            : `❌ **FAIL** - Critical security issues must be resolved before merge.\n`
+          
+          // Sauvegarder si c'est un worktree
+          if (target !== 'main') {
+            const worktreePath = join(gitRoot, "worktrees", target)
+            if (existsSync(worktreePath)) {
+              writeFileSync(join(worktreePath, '.agent-security'), report)
+            }
+          }
+          
+          logEvent("info", "Security scan completed", { target, riskLevel, vulnCount: vulnerabilities?.length || 0 })
+          
+          return getUpdateNotification() + report
+        }
+      }),
     },
 
     // Event hooks
@@ -1126,6 +1463,77 @@ Use this at the end of the MAD workflow to ensure code quality.`,
         })
       }
     },
+
+    // Hook to enforce agent constraints before tool execution
+    hook: {
+      "tool.execute.before": async (input: any, output: any) => {
+        const perms = agentPermissions.get(input.sessionID)
+        
+        // If no permissions registered, let it pass (backwards compatibility)
+        if (!perms) return
+        
+        const toolName = input.tool
+        const args = output.args || {}
+        
+        // 1. Block edit/write/patch for read-only agents
+        if (['edit', 'write', 'patch', 'multiedit'].includes(toolName)) {
+          if (!perms.canEdit) {
+            logEvent("warn", `BLOCKED: ${perms.type} tried to use ${toolName}`, { sessionID: input.sessionID })
+            throw new Error(`🚫 BLOCKED: Agent type '${perms.type}' cannot use '${toolName}' tool. This agent is READ-ONLY.`)
+          }
+          
+          // 2. Check path if allowedPaths is defined
+          const targetPath = args.filePath || args.file_path || args.path
+          if (targetPath) {
+            // Check denied paths
+            if (perms.deniedPaths.some((p: string) => targetPath.includes(p) || matchGlob(targetPath, p))) {
+              logEvent("warn", `BLOCKED: ${perms.type} tried to edit denied path`, { sessionID: input.sessionID, path: targetPath })
+              throw new Error(`🚫 BLOCKED: Cannot edit '${targetPath}' - this path is explicitly denied for this agent.`)
+            }
+            
+            // Check allowed paths (if defined)
+            if (perms.allowedPaths && perms.allowedPaths.length > 0) {
+              const isAllowed = perms.allowedPaths.some((p: string) => targetPath.includes(p) || matchGlob(targetPath, p))
+              if (!isAllowed) {
+                logEvent("warn", `BLOCKED: ${perms.type} tried to edit outside allowed paths`, { sessionID: input.sessionID, path: targetPath, allowedPaths: perms.allowedPaths })
+                throw new Error(`🚫 BLOCKED: Cannot edit '${targetPath}' - outside allowed paths: ${perms.allowedPaths.join(', ')}`)
+              }
+            }
+          }
+        }
+        
+        // 3. For bash, check if trying to modify files
+        if (toolName === 'bash' && perms && !perms.canEdit) {
+          const cmd = args.command || ''
+          const dangerousPatterns = [
+            /\becho\s+.*>/,      // echo > file
+            /\bcat\s+.*>/,       // cat > file
+            /\brm\s+/,           // rm
+            /\bmv\s+/,           // mv
+            /\bcp\s+/,           // cp (can create files)
+            /\bmkdir\s+/,        // mkdir
+            /\btouch\s+/,        // touch
+            /\bnpm\s+install/,   // npm install (modifies node_modules)
+            /\bgit\s+commit/,    // git commit
+            /\bgit\s+push/,      // git push
+          ]
+          
+          for (const pattern of dangerousPatterns) {
+            if (pattern.test(cmd)) {
+              logEvent("warn", `BLOCKED: ${perms.type} tried dangerous bash command`, { sessionID: input.sessionID, command: cmd })
+              throw new Error(`🚫 BLOCKED: Agent type '${perms.type}' cannot run '${cmd}' - this command modifies files and this agent is READ-ONLY.`)
+            }
+          }
+        }
+        
+        // 4. Force CWD in worktree for agents with worktree
+        if (toolName === 'bash' && perms?.worktree && args.command) {
+          // Prefix command with cd to worktree
+          const worktreePath = perms.worktree.replace(/\\/g, '/')
+          output.args.command = `cd "${worktreePath}" && ${args.command}`
+        }
+      }
+    },
   }
 }