agentsys 5.0.0

package/plugins/deslop/agents/deslop-agent.md

@@ -0,0 +1,88 @@
+---
+name: deslop-agent
+description: Clean AI slop from code. Invoke deslop skill and return structured results.
+tools:
+  - Bash(git:*)
+  - Bash(node:*)
+  - Skill
+  - Read
+  - Glob
+  - Grep
+model: sonnet
+---
+
+# Deslop Agent
+
+Analyze codebase for AI slop patterns using the deslop skill, then return structured results.
+
+## Workflow
+
+### 1. Parse Arguments
+
+Extract from prompt:
+- **Mode**: `report` (default) or `apply`
+- **Scope**: `all` (default), `diff`, or path
+- **Thoroughness**: `quick`, `normal` (default), or `deep`
+
+### 2. Invoke Deslop Skill
+
+```
+Skill: deslop
+Args: <mode> --scope=<scope> --thoroughness=<level>
+```
+
+The skill returns structured findings with certainty levels (HIGH, MEDIUM, LOW).
+
+### 3. Extract Fixable Items
+
+From the skill results, extract items where:
+- `certainty === 'HIGH'`
+- `autoFix` is a fix strategy (not `'flag'` or `'none'`)
+
+Valid autoFix strategies: `'remove'`, `'replace'`, `'add_logging'`
+
+Build the `fixes` array for orchestrator to pass to simple-fixer.
+
+### 4. Return Structured Results
+
+Always output structured JSON between markers:
+
+```
+=== DESLOP_RESULT ===
+{
+  "mode": "report|apply",
+  "scope": "all|diff|path",
+  "filesScanned": N,
+  "findings": {
+    "high": N,
+    "medium": N,
+    "low": N
+  },
+  "fixes": [
+    {
+      "file": "src/api.js",
+      "line": 42,
+      "fixType": "remove-line",
+      "pattern": "debug-statement"
+    }
+  ],
+  "autoFixable": N,
+  "flagged": N
+}
+=== END_RESULT ===
+```
+
+## Constraints
+
+- Do NOT modify files - only report findings
+- Do NOT spawn subagents - return data for orchestrator
+- HIGH certainty items go in `fixes` array
+- MEDIUM/LOW items go in findings summary
+- Respect .gitignore and exclude patterns
+- Skip generated files (dist/, build/, *.min.js)
+
+## Error Handling
+
+- **Git not available**: Exit with error in result
+- **Invalid scope path**: Report error, return empty findings
+- **Parse errors**: Skip file, continue with others

package/plugins/deslop/commands/deslop.md

@@ -0,0 +1,168 @@
+---
+description: This skill should be used when the user asks to "clean up slop", "remove AI artifacts", "deslop the codebase", "find debug statements", "remove console.logs", "repo hygiene", or mentions "AI slop", "code cleanup", "slop detection".
+codex-description: 'Use when user asks to "clean up slop", "remove AI artifacts", "deslop the codebase", "find debug statements", "remove console.logs", "repo hygiene". Detects and removes AI-generated slop patterns.'
+argument-hint: "[report|apply] [--scope=path] [--thoroughness=quick|normal|deep]"
+allowed-tools: Task, Read
+---
+
+# /deslop - AI Slop Cleanup
+
+Senior maintainer performing periodic repo hygiene. Mission: remove AI-generated slop while preserving behavior and minimizing diffs.
+
+## Constraints (Priority Order)
+
+When constraints conflict, follow this priority:
+
+1. **Preserve behavior and public APIs** (highest priority)
+2. **Minimal diffs** - do not reformat unrelated code
+3. **Prefer deletion over invention**
+4. **No new dependencies or abstractions**
+5. **Respect repo conventions** (check CLAUDE.md/AGENTS.md)
+
+## Arguments
+
+Parse from $ARGUMENTS or use defaults:
+
+- **Mode**: `report` (default) or `apply`
+- **Scope**: `all` (default), `diff`, or path
+- **Thoroughness**: `quick`, `normal` (default), or `deep`
+
+## Execution
+
+### Phase 1: Spawn Deslop Agent
+
+```javascript
+// Parse arguments
+const args = '$ARGUMENTS'.split(' ').filter(Boolean);
+const mode = args.includes('apply') ? 'apply' : 'report';
+const thoroughness = args.find(a => a.startsWith('--thoroughness='))?.split('=')[1] || 'normal';
+const scope = args.find(a => a.startsWith('--scope='))?.split('=')[1] ||
+              args.find(a => !a.startsWith('-') && a !== 'report' && a !== 'apply') || 'all';
+
+// Spawn agent to get findings
+const result = await Task({
+  subagent_type: "deslop:deslop-agent",
+  prompt: `Scan for AI slop patterns.
+Mode: ${mode}
+Scope: ${scope}
+Thoroughness: ${thoroughness}
+
+Return structured results between === DESLOP_RESULT === markers.`
+});
+```
+
+### Phase 2: Parse Agent Results
+
+Extract structured JSON from agent output:
+
+```javascript
+function parseDeslop(output) {
+  const match = output.match(/=== DESLOP_RESULT ===[\s\S]*?({[\s\S]*?})[\s\S]*?=== END_RESULT ===/);
+  return match ? JSON.parse(match[1]) : { fixes: [] };
+}
+
+const findings = parseDeslop(result);
+```
+
+### Phase 3: Handle Mode
+
+#### Report Mode (Default)
+
+Present findings as markdown table:
+
+```markdown
+## Slop Hotspots
+
+| Priority | File | Issue | Certainty | Fix |
+|----------|------|-------|-----------|-----|
+| 1 | src/api.js:42 | console.log | HIGH | auto |
+| 2 | src/auth.js:15 | empty catch | HIGH | auto |
+| 3 | lib/utils.js:88 | excessive comments | MEDIUM | review |
+
+## Summary
+
+- **HIGH certainty**: N (auto-fixable)
+- **MEDIUM certainty**: N (review required)
+- **LOW certainty**: N (flagged only)
+
+## Do Next
+
+- [ ] Run `/deslop apply` to auto-fix HIGH certainty items
+- [ ] Review MEDIUM certainty items manually
+```
+
+#### Apply Mode
+
+If fixes array is non-empty, spawn simple-fixer:
+
+```javascript
+if (mode === 'apply' && findings?.fixes?.length > 0) {
+  await Task({
+    subagent_type: "next-task:simple-fixer",
+    model: "haiku",
+    prompt: `Apply these slop fixes:
+${JSON.stringify(findings.fixes, null, 2)}
+
+For each fix:
+- remove-line: Delete the line at the specified line number
+- add-comment: Add "// Error intentionally ignored" to empty catch
+- remove-block: Delete the entire code block
+
+Use Edit tool to apply. Commit message: "fix: clean up AI slop (auto-applied)"`
+  });
+}
+```
+
+Present results:
+
+```markdown
+## Applied Fixes
+
+| File | Line | Fix |
+|------|------|-----|
+| src/api.js | 42 | remove-line (console.log) |
+| src/auth.js | 15 | add-comment (empty catch) |
+
+**Total**: N fixes applied
+
+## Remaining (manual review needed)
+
+| File | Line | Issue | Certainty |
+|------|------|-------|-----------|
+| lib/utils.js | 88 | excessive comments | MEDIUM |
+```
+
+## Verification Strategy
+
+After fixes are applied, run project's test command:
+
+```bash
+npm test
+# or pytest, cargo test, go test ./...
+```
+
+On failure: `git restore .` and report which change failed.
+
+## Ignore Zones
+
+Skip these paths (handled by detection script):
+- Build artifacts: `dist/`, `build/`, `target/`, `out/`, `.next/`
+- Vendored: `vendor/`, `node_modules/`, `**/*.min.*`
+- Generated: `**/*.gen.*`, lockfiles
+
+## Error Handling
+
+- Git not available: Exit with "Git required for rollback safety"
+- Invalid scope path: Exit with "Path not found: <path>"
+- Verification fails: Rollback with `git restore .`, report failure
+
+## Additional Resources
+
+### Reference Files
+
+For detailed pattern documentation, consult:
+- **`references/slop-categories.md`** - All pattern categories, severity levels, certainty thresholds, auto-fix strategies
+
+### Scripts
+
+- **`scripts/detect.js`** - Detection pipeline CLI (run with `--help` for options)

package/plugins/deslop/lib/adapter-transforms.js

@@ -0,0 +1,278 @@
+/**
+ * Adapter Transform Functions
+ *
+ * Shared transforms for converting Claude Code plugin content into
+ * OpenCode and Codex adapter formats. Used by:
+ *   - bin/cli.js (npm installer)
+ *   - scripts/dev-install.js (development installer)
+ *   - scripts/gen-adapters.js (static adapter generation)
+ *
+ * @module adapter-transforms
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const discovery = require('./discovery');
+
+function transformBodyForOpenCode(content, repoRoot) {
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${PLUGIN_ROOT}');
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, '$PLUGIN_ROOT');
+
+  content = content.replace(/\.claude\//g, '.opencode/');
+  content = content.replace(/\.claude'/g, ".opencode'");
+  content = content.replace(/\.claude"/g, '.opencode"');
+  content = content.replace(/\.claude`/g, '.opencode`');
+
+  const plugins = discovery.discoverPlugins(repoRoot);
+  if (plugins.length > 0) {
+    const pluginNames = plugins.join('|');
+    content = content.replace(new RegExp('`(' + pluginNames + '):([a-z-]+)`', 'g'), '`$2`');
+    content = content.replace(new RegExp('(' + pluginNames + '):([a-z-]+)', 'g'), '$2');
+  }
+
+  content = content.replace(
+    /```(\w*)\n([\s\S]*?)```/g,
+    (match, lang, code) => {
+      const langLower = (lang || '').toLowerCase();
+
+      if (langLower === 'bash' || langLower === 'shell' || langLower === 'sh') {
+        if (code.includes('node -e') && code.includes('require(')) {
+          return '*(Bash command with Node.js require - adapt for OpenCode)*';
+        }
+        return match;
+      }
+
+      if (!lang && (code.trim().startsWith('gh ') || code.trim().startsWith('glab ') ||
+          code.trim().startsWith('git ') || code.trim().startsWith('#!'))) {
+        return match;
+      }
+
+      if (code.includes('require(') || code.includes('Task(') ||
+          code.includes('const ') || code.includes('let ') ||
+          code.includes('function ') || code.includes('=>') ||
+          code.includes('async ') || code.includes('await ')) {
+
+        let instructions = '';
+
+        const taskMatches = [...code.matchAll(/(?:await\s+)?Task\s*\(\s*\{[^}]*subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["'][^}]*\}\s*\)/gs)];
+        for (const taskMatch of taskMatches) {
+          const agent = taskMatch[1];
+          instructions += `- Invoke \`@${agent}\` agent\n`;
+        }
+
+        const phaseMatches = code.match(/startPhase\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+        if (phaseMatches) {
+          for (const pm of phaseMatches) {
+            const phase = pm.match(/['"]([^'"]+)['"]/)[1];
+            instructions += `- Phase: ${phase}\n`;
+          }
+        }
+
+        if (code.includes('AskUserQuestion')) {
+          instructions += '- Use AskUserQuestion tool for user input\n';
+        }
+
+        if (code.includes('EnterPlanMode')) {
+          instructions += '- Use EnterPlanMode for user approval\n';
+        }
+
+        if (instructions) {
+          return instructions;
+        }
+
+        return '*(JavaScript reference - not executable in OpenCode)*';
+      }
+
+      return match;
+    }
+  );
+
+  content = content.replace(/\*\(Reference - adapt for OpenCode\)\*/g, '');
+
+  content = content.replace(/await\s+Task\s*\(\s*\{[\s\S]*?\}\s*\);?/g, (match) => {
+    const agentMatch = match.match(/subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["']/);
+    if (agentMatch) {
+      return `Invoke \`@${agentMatch[1]}\` agent`;
+    }
+    return '*(Task call - use @agent-name syntax)*';
+  });
+
+  content = content.replace(/(?:const|let|var)\s+\{?[^}=\n]+\}?\s*=\s*require\s*\([^)]+\);?/g, '');
+  content = content.replace(/require\s*\(['"][^'"]+['"]\)/g, '');
+
+  if (content.includes('agent')) {
+    const note = `
+> **OpenCode Note**: Invoke agents using \`@agent-name\` syntax.
+> Available agents: task-discoverer, exploration-agent, planning-agent,
+> implementation-agent, deslop-agent, delivery-validator, sync-docs-agent, consult-agent
+> Example: \`@exploration-agent analyze the codebase\`
+
+`;
+    content = content.replace(/^(---\n[\s\S]*?---\n)/, `$1${note}`);
+  }
+
+  if (content.includes('Master Workflow Orchestrator') && content.includes('No Shortcuts Policy')) {
+    const policySection = `
+## Phase 1: Policy Selection (Built-in Options)
+
+Ask the user these questions using AskUserQuestion:
+
+**Question 1 - Source**: "Where should I look for tasks?"
+- GitHub Issues - Use \`gh issue list\` to find issues
+- GitLab Issues - Use \`glab issue list\` to find issues
+- Local tasks.md - Read from PLAN.md, tasks.md, or TODO.md in the repo
+- Custom - User specifies their own source
+- Other - User describes source, you figure it out
+
+**Question 2 - Priority**: "What type of tasks to prioritize?"
+- All - Consider all tasks, pick by score
+- Bugs - Focus on bug fixes
+- Security - Security issues first
+- Features - New feature development
+
+**Question 3 - Stop Point**: "How far should I take this task?"
+- Merged - Until PR is merged to main
+- PR Created - Stop after creating PR
+- Implemented - Stop after local implementation
+- Deployed - Deploy to staging
+- Production - Full production deployment
+
+After user answers, proceed to Phase 2 with the selected policy.
+
+`;
+    if (content.includes('OpenCode Note')) {
+      content = content.replace(/(Example:.*analyze the codebase\`\n\n)/, `$1${policySection}`);
+    }
+  }
+
+  return content;
+}
+
+function transformCommandFrontmatterForOpenCode(content) {
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode command frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'agent: general\n';
+      // Don't include argument-hint or allowed-tools (not supported)
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformAgentFrontmatterForOpenCode(content, options) {
+  const { stripModels = true } = options || {};
+
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.name) opencodeFrontmatter += `name: ${parsed.name}\n`;
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'mode: subagent\n';
+
+      // Map model names - only include if NOT stripping
+      if (parsed.model && !stripModels) {
+        const modelMap = {
+          'sonnet': 'anthropic/claude-sonnet-4',
+          'opus': 'anthropic/claude-opus-4',
+          'haiku': 'anthropic/claude-haiku-3-5'
+        };
+        opencodeFrontmatter += `model: ${modelMap[parsed.model] || parsed.model}\n`;
+      }
+
+      // Convert tools to permissions
+      if (parsed.tools) {
+        opencodeFrontmatter += 'permission:\n';
+        const tools = parsed.tools.toLowerCase();
+        opencodeFrontmatter += `  read: ${tools.includes('read') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  edit: ${tools.includes('edit') || tools.includes('write') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  bash: ${tools.includes('bash') ? 'allow' : 'ask'}\n`;
+        opencodeFrontmatter += `  glob: ${tools.includes('glob') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  grep: ${tools.includes('grep') ? 'allow' : 'deny'}\n`;
+      }
+
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformSkillBodyForOpenCode(content, repoRoot) {
+  return transformBodyForOpenCode(content, repoRoot);
+}
+
+function transformForCodex(content, options) {
+  const { skillName, description, pluginInstallPath } = options;
+
+  // Escape description for YAML: wrap in double quotes, escape backslashes and internal quotes
+  const escapedDescription = description.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const yamlDescription = `"${escapedDescription}"`;
+
+  if (content.startsWith('---')) {
+    // Replace existing frontmatter with Codex-compatible format
+    content = content.replace(
+      /^---\n[\s\S]*?\n---\n/,
+      `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n`
+    );
+  } else {
+    // Add new frontmatter
+    content = `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n\n${content}`;
+  }
+
+  // Transform PLUGIN_ROOT to actual installed path (or placeholder) for Codex
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, pluginInstallPath);
+  content = content.replace(/\$\{PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$PLUGIN_ROOT/g, pluginInstallPath);
+
+  // Transform AskUserQuestion → request_user_input for Codex native tool
+  content = content.replace(/AskUserQuestion/g, 'request_user_input');
+
+  // Remove multiSelect lines (not supported in Codex)
+  content = content.replace(/^[ \t]*multiSelect:.*\n?/gm, '');
+
+  // Inject Codex note about required id field after request_user_input blocks
+  content = content.replace(
+    /^([ \t]*request_user_input:\s*)$/gm,
+    '$1\n> **Codex**: Each question MUST include a unique `id` field (e.g., `id: "q1"`).'
+  );
+
+  return content;
+}
+
+module.exports = {
+  transformBodyForOpenCode,
+  transformCommandFrontmatterForOpenCode,
+  transformAgentFrontmatterForOpenCode,
+  transformSkillBodyForOpenCode,
+  transformForCodex
+};