agentsys 5.0.0

package/plugins/deslop/scripts/detect.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Slop Detection CLI
+ * Runs the detection pipeline and outputs structured findings
+ *
+ * Usage: node detect.js [path] [--apply] [--deep] [--compact]
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Resolve lib relative to script location (works with ${CLAUDE_PLUGIN_ROOT})
+const libPath = path.join(__dirname, '..', 'lib');
+const { runPipeline } = require(path.join(libPath, 'patterns', 'pipeline'));
+
+function parseArgs(args) {
+  const options = {
+    path: '.',
+    mode: 'report',
+    thoroughness: 'normal',
+    compact: false,
+    maxFindings: 10
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--apply') {
+      options.mode = 'apply';
+    } else if (arg === '--deep') {
+      options.thoroughness = 'deep';
+    } else if (arg === '--quick') {
+      options.thoroughness = 'quick';
+    } else if (arg === '--compact') {
+      options.compact = true;
+    } else if (arg === '--max' && args[i + 1]) {
+      options.maxFindings = parseInt(args[++i], 10);
+    } else if (!arg.startsWith('-')) {
+      options.path = arg;
+    }
+  }
+
+  return options;
+}
+
+function formatFindings(result, compact, maxFindings = 10) {
+  // Handle pipeline output format (has 'findings' array or 'summary' object)
+  const findings = result.findings || [];
+  const summary = result.summary || {};
+
+  if (compact) {
+    // Compact table format for token efficiency
+    console.log('\n## Slop Detection Results\n');
+    console.log('| File | Line | Pattern | Severity | Certainty |');
+    console.log('|------|------|---------|----------|-----------|');
+
+    for (const finding of findings.slice(0, maxFindings)) {
+      const file = (finding.file || finding.path || '').length > 30
+        ? '...' + (finding.file || finding.path || '').slice(-27)
+        : (finding.file || finding.path || '');
+      const line = finding.line || finding.lineNumber || '-';
+      const pattern = finding.patternName || finding.pattern || finding.type || 'unknown';
+      const severity = finding.severity || 'medium';
+      const certainty = finding.certainty || 'MEDIUM';
+      console.log(`| ${file} | ${line} | ${pattern} | ${severity} | ${certainty} |`);
+    }
+
+    const total = summary.totalFindings || findings.length;
+    const bySeverity = summary.bySeverity || {};
+    console.log(`\n**Total**: ${total} findings`);
+    console.log(`**By Severity**: critical=${bySeverity.critical || 0}, high=${bySeverity.high || 0}, medium=${bySeverity.medium || 0}, low=${bySeverity.low || 0}`);
+  } else {
+    // Full JSON output
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Help
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Slop Detection CLI
+
+Usage: node detect.js [path] [options]
+
+Options:
+  --apply      Apply auto-fixes (default: report only)
+  --deep       Deep analysis with all analyzers
+  --quick      Quick regex-only scan
+  --compact    Output as markdown table (token efficient)
+  --max N      Maximum findings to return (default: 10)
+  --help       Show this help
+
+Examples:
+  node detect.js                    # Scan current directory
+  node detect.js src/               # Scan src/ directory
+  node detect.js --apply --compact  # Fix and show compact results
+`);
+    process.exit(0);
+  }
+
+  const options = parseArgs(args);
+
+  // Validate path exists
+  if (!fs.existsSync(options.path)) {
+    console.error(`Error: Path not found: ${options.path}`);
+    process.exit(1);
+  }
+
+  try {
+    // runPipeline takes (repoPath, options) - async function
+    const result = await runPipeline(options.path, {
+      mode: options.mode,
+      thoroughness: options.thoroughness
+    });
+
+    formatFindings(result, options.compact, options.maxFindings);
+
+    // Exit with error code if critical findings
+    const bySeverity = result.summary?.bySeverity || {};
+    if (bySeverity.critical > 0) {
+      process.exit(2);
+    }
+  } catch (error) {
+    console.error(`Error running detection: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/plugins/deslop/skills/deslop/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: deslop
+description: "Use when user wants to clean AI slop from code. Use for cleanup, remove debug statements, find ghost code, repo hygiene."
+version: 5.0.0
+argument-hint: "[report|apply] [--scope=all|diff|path] [--thoroughness=quick|normal|deep]"
+---
+
+# deslop
+
+Clean AI slop from code with certainty-based findings and auto-fixes.
+
+## Parse Arguments
+
+```javascript
+const args = '$ARGUMENTS'.split(' ').filter(Boolean);
+const mode = args.find(a => ['report', 'apply'].includes(a)) || 'report';
+const scope = args.find(a => a.startsWith('--scope='))?.split('=')[1] || 'all';
+const thoroughness = args.find(a => a.startsWith('--thoroughness='))?.split('=')[1] || 'normal';
+```
+
+## Input
+
+Arguments: `[report|apply] [--scope=<path>|all|diff] [--thoroughness=quick|normal|deep]`
+
+- **Mode**: `report` (default) or `apply`
+- **Scope**: What to scan
+  - `all` (default): Entire codebase
+  - `diff`: Only files changed in current branch
+  - `<path>`: Specific directory or file
+- **Thoroughness**: Analysis depth (default: `normal`)
+  - `quick`: Regex patterns only
+  - `normal`: + multi-pass analyzers
+  - `deep`: + CLI tools (jscpd, madge) if available
+
+## Detection Pipeline
+
+### Phase 1: Run Detection Script
+
+The detection script is at `../../scripts/detect.js` relative to this skill.
+
+**Run detection** (use relative path from skill directory):
+```bash
+# Scripts are at plugin root: ../../scripts/ from skills/deslop/
+node ../../scripts/detect.js . --thoroughness normal --compact --max 50
+```
+
+**For diff scope** (only changed files):
+```bash
+BASE=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
+# Use newline-separated list to safely handle filenames with special chars
+git diff --name-only origin/${BASE}..HEAD 2>/dev/null | \
+  xargs -d '\n' node ../../scripts/detect.js --thoroughness normal --compact
+```
+
+**Note**: The relative path `../../scripts/detect.js` navigates from `skills/deslop/` up to the plugin root where `scripts/` lives.
+
+### Phase 2: Repo-Map Enhancement (Optional)
+
+If repo-map exists, enhance detection with AST-based analysis:
+
+```javascript
+// Use relative path from skill directory to plugin lib
+// Path: skills/deslop/ -> ../../lib/repo-map
+const repoMap = require('../../lib/repo-map');
+
+if (repoMap.exists(basePath)) {
+  const map = repoMap.load(basePath);
+  const usageIndex = repoMap.buildUsageIndex(map);
+
+  // Find orphaned infrastructure with HIGH certainty
+  const orphaned = repoMap.findOrphanedInfrastructure(map, usageIndex);
+  for (const item of orphaned) {
+    findings.push({
+      file: item.file,
+      line: item.line,
+      pattern: 'orphaned-infrastructure',
+      message: `${item.name} (${item.type}) is never used`,
+      certainty: 'HIGH',
+      severity: 'high',
+      autoFix: false
+    });
+  }
+
+  // Find unused exports
+  const unusedExports = repoMap.findUnusedExports(map, usageIndex);
+  for (const item of unusedExports) {
+    findings.push({
+      file: item.file,
+      line: item.line,
+      pattern: 'unused-export',
+      message: `Export '${item.name}' is never imported`,
+      certainty: item.certainty,
+      severity: 'medium',
+      autoFix: false
+    });
+  }
+}
+```
+
+### Phase 3: Aggregate and Prioritize
+
+Sort findings by:
+1. **Certainty**: HIGH before MEDIUM before LOW
+2. **Severity**: high before medium before low
+3. **Fix complexity**: auto-fixable before manual
+
+### Phase 4: Return Structured Results
+
+Skill returns structured JSON - does NOT apply fixes (orchestrator handles that).
+
+## Output Format
+
+JSON structure between markers:
+
+```
+=== DESLOP_RESULT ===
+{
+  "mode": "report|apply",
+  "scope": "all|diff|path",
+  "filesScanned": N,
+  "findings": [
+    {
+      "file": "src/api.js",
+      "line": 42,
+      "pattern": "debug-statement",
+      "message": "console.log found",
+      "certainty": "HIGH",
+      "severity": "medium",
+      "autoFix": true,
+      "fixType": "remove-line"
+    }
+  ],
+  "fixes": [
+    {
+      "file": "src/api.js",
+      "line": 42,
+      "fixType": "remove-line",
+      "pattern": "debug-statement"
+    }
+  ],
+  "summary": {
+    "high": N,
+    "medium": N,
+    "low": N,
+    "autoFixable": N
+  }
+}
+=== END_RESULT ===
+```
+
+## Certainty Levels
+
+| Level | Meaning | Action |
+|-------|---------|--------|
+| **HIGH** | Definitely slop, safe to auto-fix | Auto-fix via simple-fixer |
+| **MEDIUM** | Likely slop, needs verification | Review first |
+| **LOW** | Possible slop, context-dependent | Flag only |
+
+## Pattern Categories
+
+### HIGH Certainty (Auto-Fixable)
+
+- `debug-statement`: console.log, console.debug, print, println!
+- `debug-import`: Unused debug/logging imports
+- `placeholder-text`: "Lorem ipsum", "TODO: implement"
+- `empty-catch`: Empty catch blocks without comment
+- `trailing-whitespace`: Trailing whitespace
+- `mixed-indentation`: Mixed tabs/spaces
+
+### MEDIUM Certainty (Review Required)
+
+- `excessive-comments`: Comment/code ratio > 2:1
+- `doc-code-ratio`: JSDoc > 3x function body
+- `stub-function`: Returns placeholder value only
+- `dead-code`: Unreachable after return/throw
+- `infrastructure-without-impl`: DB clients created but never used
+
+### LOW Certainty (Flag Only)
+
+- `over-engineering`: File/export ratio > 20x
+- `buzzword-inflation`: Claims without evidence
+- `shotgun-surgery`: Files frequently change together
+
+## Fix Types
+
+| Fix Type | Action | Patterns |
+|----------|--------|----------|
+| `remove-line` | Delete line | debug-statement, debug-import |
+| `add-comment` | Add explanation | empty-catch |
+| `remove-block` | Delete code block | stub-function with TODO |
+
+## Error Handling
+
+- **Git not available**: Skip git-dependent checks
+- **Invalid scope**: Return error in JSON
+- **Parse errors**: Skip file, continue scan
+
+## Integration
+
+This skill is invoked by:
+- `deslop-agent` for `/deslop` command
+- `/next-task` Phase 8 (pre-review gates) with `scope=diff`
+
+The orchestrator spawns `simple-fixer` to apply HIGH certainty fixes.

package/plugins/drift-detect/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "drift-detect",
+  "version": "5.0.0",
+  "description": "Deep repository analysis to realign project plans with actual code reality - discovers drift, gaps, and produces prioritized reconstruction plans",
+  "author": {
+    "name": "Avi Fenesh",
+    "email": "[email protected]",
+    "url": "https://github.com/avifenesh"
+  },
+  "homepage": "https://github.com/avifenesh/agentsys#drift-detect",
+  "repository": "https://github.com/avifenesh/agentsys",
+  "license": "MIT",
+  "keywords": [
+    "planning",
+    "drift-detect",
+    "drift-detection",
+    "prioritization",
+    "exploration",
+    "documentation",
+    "github-issues",
+    "project-management"
+  ]
+}

package/plugins/drift-detect/agents/plan-synthesizer.md

@@ -0,0 +1,225 @@
+---
+name: plan-synthesizer
+description: Perform deep semantic analysis on collected project data to identify drift, gaps, and create a prioritized reconstruction plan. Use this agent for the single LLM analysis call after JavaScript data collection.
+tools:
+  - Read
+  - Write
+model: opus
+---
+
+# Plan Synthesizer Agent
+
+You perform deep semantic analysis on project data collected by the JavaScript collectors module. Your role is to identify patterns, drift, and gaps that require human-level reasoning - not just data extraction.
+
+## Input Format
+
+You receive all collected data as structured JSON in the prompt:
+- `github`: Issues, PRs, milestones, categorized items, stale items, themes
+- `docs`: Documentation files analysis, checkboxes, features, plans, gaps
+- `code`: Directory structure, frameworks, test framework, health indicators, implemented features
+
+## Your Unique Value
+
+The JavaScript collectors already extracted structured data. Your job is to deliver **BRUTALLY SPECIFIC** insights:
+
+1. **Issue Verification**: For EACH issue, determine if it's already done, stale, or blocked
+   - "Close issue #45 - already implemented in src/auth/login.js"
+   - "Issue #23 is stale - the feature was removed in v2.0"
+
+2. **Phase Validation**: For EACH phase/checkbox marked complete, verify against code
+   - "Phase 'Auth' marked complete but MISSING: password reset, session timeout, tests"
+
+3. **Release Blockers**: If milestones exist, assess ship-readiness
+   - "Cannot release tomorrow: 3 tests missing, security issue #78 open"
+
+4. **Actionable Commands**: Not generic advice, but specific actions
+   - "Close: #12, #34, #56"
+   - "Reopen Phase C"
+   - "Block release until: X, Y, Z"
+
+## Analysis Process
+
+### Step 1: Understand the Project Context
+
+Before diving into analysis, understand:
+- What type of project is this? (library, app, CLI, etc.)
+- What frameworks/technologies are used?
+- What's the project's maturity level?
+- What are the documented goals?
+
+### Step 2: Cross-Reference Analysis
+
+Compare documented features against actual implementation using semantic matching:
+
+**Matching Logic:**
+- "user authentication" ↔ auth/, login.js, session handling
+- "API endpoints" ↔ routes/, handlers/, controllers/
+- "database" ↔ models/, migrations/, schema
+- Consider synonyms and related concepts
+
+**Categories:**
+1. **Documented but not implemented**: Features in docs/issues but no matching code
+2. **Implemented but not documented**: Code exists but no docs mention it
+3. **Partially implemented**: Some code exists but incomplete
+4. **Fully aligned**: Docs and code match
+
+### Step 3: Identify Drift
+
+Look for signs of plan/reality divergence:
+
+**Plan Drift:**
+- PLAN.md has low completion rate (< 30%) with many items
+- Phases marked "complete" but code shows otherwise
+- Milestones overdue with significant work remaining
+
+**Issue Drift:**
+- High-priority issues stale > 90 days
+- Issues marked "in progress" but no recent commits
+- Duplicate issues indicating confusion
+
+**Documentation Drift:**
+- README describes features that don't exist
+- API docs don't match actual exports
+- CHANGELOG missing recent changes
+
+**Scope Drift:**
+- Many features documented but few implemented (overcommit)
+- Many features implemented but not documented (underdocumented)
+
+### Step 4: Identify Gaps
+
+**Critical Gaps (blocks progress):**
+- No tests for implemented features
+- Security issues open
+- Missing error handling in critical paths
+- No CI/CD pipeline
+
+**High Gaps (impacts quality):**
+- No README or setup instructions
+- Missing API documentation
+- No contribution guidelines
+- Tests exist but don't cover critical paths
+
+**Medium Gaps (tech debt):**
+- Outdated dependencies
+- Missing TypeScript types
+- Incomplete error messages
+- No logging/monitoring
+
+### Step 5: Prioritize with Context
+
+Don't just sort by severity - reason about context:
+
+**Questions to consider:**
+- Does this security issue have a workaround?
+- Does this bug block other work?
+- Is this feature already partially implemented?
+- Will fixing this unlock multiple other tasks?
+- Is this a quick win or major effort?
+
+**Priority Formula:**
+```
+Priority = BaseSeverity + CategoryWeight + BlockerBonus + QuickWinBonus
+```
+
+### Step 6: Generate Report
+
+Output a comprehensive markdown report:
+
+```markdown
+# Reality Check Report
+
+Generated: [timestamp]
+
+## Executive Summary
+
+[2-3 sentence overview of project state]
+
+**Key Numbers:**
+- Drift Areas: X
+- Critical Gaps: Y
+- Work Items: Z
+- Features Aligned: W
+
+## Drift Analysis
+
+### [Drift Type 1]
+**Severity:** critical/high/medium/low
+**Description:** [What's drifting and why it matters]
+**Evidence:** [Specific examples from data]
+**Recommendation:** [Actionable fix]
+
+[... more drift items ...]
+
+## Gap Analysis
+
+### [Gap Type 1]
+**Severity:** critical/high/medium/low
+**Category:** security/quality/documentation/infrastructure
+**Description:** [What's missing]
+**Impact:** [Why this matters]
+**Recommendation:** [How to fix]
+
+[... more gaps ...]
+
+## Cross-Reference Findings
+
+### Documented but Not Implemented
+- [Feature 1] - documented in README, no matching code
+- [Feature 2] - in PLAN.md Phase 2, not started
+
+### Implemented but Not Documented
+- [Feature A] - auth/ exists but not mentioned in docs
+- [Feature B] - API has /users endpoint but no docs
+
+### Fully Aligned
+- [Feature X] - docs match implementation
+- [Feature Y] - docs match implementation
+
+## Prioritized Reconstruction Plan
+
+### Immediate (This Week)
+1. **[Critical Item]** - [why urgent]
+2. **[Critical Item]** - [why urgent]
+
+### Short Term (This Month)
+1. [High priority item]
+2. [High priority item]
+
+### Medium Term (This Quarter)
+1. [Medium priority item]
+2. [Medium priority item]
+
+### Backlog
+1. [Lower priority item]
+2. [Lower priority item]
+
+## Actionable Quick Wins
+
+These can be done quickly with high impact:
+1. Close issue #X - already implemented
+2. Update README to mention existing feature Y
+3. Add test for critical path Z
+
+---
+*Generated by drift-detect plugin*
+```
+
+## Model Choice: Opus
+
+This agent uses **opus** because it performs complex reasoning:
+- Semantic matching across different naming conventions
+- Priority reasoning that considers context, not just rules
+- Cross-referencing multiple data sources simultaneously
+- Generating nuanced, actionable recommendations
+
+The JavaScript collectors handle all data extraction. Opus focuses on understanding and synthesis.
+
+## Success Criteria
+
+- Report clearly distinguishes semantic insights from raw data
+- Drift items have specific examples and evidence
+- Gaps are actionable with clear recommendations
+- Prioritization explains reasoning, not just severity
+- Quick wins are genuinely quick and high-impact
+- Cross-reference uses fuzzy matching, not exact strings