agentsys 5.3.4 → 5.3.5

package/.cursor/commands/delivery-approval.md

@@ -1,334 +0,0 @@
-
-# /delivery-approval - Delivery Validation
-
-Validate that the current work is complete and ready to ship.
-This command runs the same validation as the workflow's delivery-validator agent.
-
-## Arguments
-
-- `--task-id ID`: Specify task ID to validate against (default: from workflow state)
-- `--verbose`: Show detailed output for each check
-
-## Parse Arguments
-
-```javascript
-const args = $ARGUMENTS.split(' ').filter(Boolean);
-const verbose = args.includes('--verbose');
-const taskIdArg = args.find(a => a.startsWith('--task-id'));
-const taskId = taskIdArg ? args[args.indexOf(taskIdArg) + 1] : null;
-```
-
-## Phase 1: Get Context
-
-```javascript
-
-
-
-const pluginRoot = getPluginRoot('next-task');
-if (!pluginRoot) {
-  console.error('Error: Could not locate next-task plugin installation');
-  process.exit(1);
-}
-
-);
-
-let task;
-let changedFiles;
-
-// Try to get from workflow state first
-const state = workflowState.readState();
-if (state?.task) {
-  task = state.task;
-} else if (taskId) {
-  // Fetch task from GitHub
-  task = await fetchGitHubIssue(taskId);
-} else {
-  // Get from recent commit message
-  task = await inferTaskFromCommits();
-}
-
-// Get changed files
-changedFiles = (await exec('git diff --name-only origin/main..HEAD')).split('\n').filter(Boolean);
-```
-
-## Phase 2: Run Validation Checks
-
-### Check 1: Git State
-
-```bash
-# Check for uncommitted changes
-UNCOMMITTED=$(git status --porcelain)
-if [ -n "$UNCOMMITTED" ]; then
-  echo "UNCOMMITTED_CHANGES=true"
-  echo "$UNCOMMITTED"
-fi
-
-# Check if ahead of remote
-AHEAD=$(git rev-list --count origin/main..HEAD)
-echo "COMMITS_AHEAD=$AHEAD"
-
-# Check branch name
-BRANCH=$(git branch --show-current)
-echo "BRANCH=$BRANCH"
-```
-
-### Check 2: Tests Pass
-
-```bash
-# Detect and run tests
-if [ -f "package.json" ]; then
-  if grep -q '"test"' package.json; then
-    echo "Running npm test..."
-    npm test 2>&1
-    TEST_RESULT=$?
-    echo "TEST_RESULT=$TEST_RESULT"
-  else
-    echo "NO_TEST_SCRIPT=true"
-  fi
-elif [ -f "pytest.ini" ] || [ -f "pyproject.toml" ]; then
-  echo "Running pytest..."
-  pytest -v 2>&1
-  TEST_RESULT=$?
-  echo "TEST_RESULT=$TEST_RESULT"
-elif [ -f "Cargo.toml" ]; then
-  echo "Running cargo test..."
-  cargo test 2>&1
-  TEST_RESULT=$?
-  echo "TEST_RESULT=$TEST_RESULT"
-elif [ -f "go.mod" ]; then
-  echo "Running go test..."
-  go test ./... -v 2>&1
-  TEST_RESULT=$?
-  echo "TEST_RESULT=$TEST_RESULT"
-fi
-```
-
-### Check 3: Build Passes
-
-```bash
-# Detect and run build
-if [ -f "package.json" ] && grep -q '"build"' package.json; then
-  echo "Running npm run build..."
-  npm run build 2>&1
-  BUILD_RESULT=$?
-  echo "BUILD_RESULT=$BUILD_RESULT"
-elif [ -f "Cargo.toml" ]; then
-  echo "Running cargo build..."
-  cargo build --release 2>&1
-  BUILD_RESULT=$?
-  echo "BUILD_RESULT=$BUILD_RESULT"
-elif [ -f "go.mod" ]; then
-  echo "Running go build..."
-  go build ./... 2>&1
-  BUILD_RESULT=$?
-  echo "BUILD_RESULT=$BUILD_RESULT"
-else
-  echo "NO_BUILD_SCRIPT=true"
-  BUILD_RESULT=0
-fi
-```
-
-### Check 4: Lint Passes
-
-```bash
-# Run linter if available
-if [ -f "package.json" ] && grep -q '"lint"' package.json; then
-  echo "Running npm run lint..."
-  npm run lint 2>&1
-  LINT_RESULT=$?
-  echo "LINT_RESULT=$LINT_RESULT"
-elif [ -f ".eslintrc.js" ] || [ -f ".eslintrc.json" ]; then
-  echo "Running eslint..."
-  npx eslint . 2>&1
-  LINT_RESULT=$?
-  echo "LINT_RESULT=$LINT_RESULT"
-else
-  echo "NO_LINTER=true"
-  LINT_RESULT=0
-fi
-```
-
-### Check 5: Type Check (TypeScript)
-
-```bash
-if [ -f "tsconfig.json" ]; then
-  echo "Running tsc --noEmit..."
-  npx tsc --noEmit 2>&1
-  TYPE_RESULT=$?
-  echo "TYPE_RESULT=$TYPE_RESULT"
-else
-  echo "NO_TYPESCRIPT=true"
-  TYPE_RESULT=0
-fi
-```
-
-## Phase 3: Check Task Requirements
-
-```javascript
-async function checkRequirements(task, changedFiles) {
-  if (!task) {
-    return { passed: true, reason: 'No task specified, skipping requirements check' };
-  }
-
-  const requirements = extractRequirements(task.description || task.body || '');
-
-  if (requirements.length === 0) {
-    return { passed: true, reason: 'No specific requirements found in task' };
-  }
-
-  // Analyze changed files for each requirement
-  const results = [];
-  for (const req of requirements) {
-    const evidence = await findEvidence(req, changedFiles);
-    results.push({
-      requirement: req,
-      implemented: evidence.found,
-      evidence: evidence.details
-    });
-  }
-
-  const allMet = results.every(r => r.implemented);
-  return {
-    passed: allMet,
-    results,
-    reason: allMet ? 'All requirements met' : 'Some requirements not implemented'
-  };
-}
-```
-
-## Phase 4: Aggregate Results
-
-```javascript
-const checks = {
-  gitState: {
-    passed: !UNCOMMITTED_CHANGES,
-    uncommitted: UNCOMMITTED_CHANGES,
-    commitsAhead: COMMITS_AHEAD,
-    branch: BRANCH
-  },
-  tests: {
-    passed: TEST_RESULT === 0,
-    exitCode: TEST_RESULT
-  },
-  build: {
-    passed: BUILD_RESULT === 0,
-    exitCode: BUILD_RESULT
-  },
-  lint: {
-    passed: LINT_RESULT === 0,
-    exitCode: LINT_RESULT
-  },
-  typeCheck: {
-    passed: TYPE_RESULT === 0,
-    exitCode: TYPE_RESULT
-  },
-  requirements: await checkRequirements(task, changedFiles)
-};
-
-const allPassed = Object.values(checks).every(c => c.passed);
-const failedChecks = Object.entries(checks)
-  .filter(([_, v]) => !v.passed)
-  .map(([k, _]) => k);
-```
-
-## Phase 5: Output Results
-
-### Summary Report
-
-```markdown
-## Delivery Validation Report
-
-**Task**: ${task?.title || 'N/A'}
-**Branch**: ${BRANCH}
-**Commits ahead of main**: ${COMMITS_AHEAD}
-
-### Validation Results
-
-| Check | Status | Details |
-|-------|--------|---------|
-| Git State | ${checks.gitState.passed ? '[OK]' : '[FAIL]'} | ${checks.gitState.uncommitted ? 'Uncommitted changes' : 'Clean'} |
-| Tests | ${checks.tests.passed ? '[OK]' : '[FAIL]'} | Exit code: ${checks.tests.exitCode} |
-| Build | ${checks.build.passed ? '[OK]' : '[FAIL]'} | Exit code: ${checks.build.exitCode} |
-| Lint | ${checks.lint.passed ? '[OK]' : '[FAIL]'} | Exit code: ${checks.lint.exitCode} |
-| Type Check | ${checks.typeCheck.passed ? '[OK]' : '[FAIL]'} | Exit code: ${checks.typeCheck.exitCode} |
-| Requirements | ${checks.requirements.passed ? '[OK]' : '[FAIL]'} | ${checks.requirements.reason} |
-
-### Overall Status
-
-${allPassed ?
-  '## [OK] APPROVED\nAll validation checks passed. Ready to ship!' :
-  `## [FAIL] NOT APPROVED\nFailed checks: ${failedChecks.join(', ')}`}
-
-${!allPassed ? `
-### Fix Required
-
-${failedChecks.map(check => {
-  switch(check) {
-    case 'gitState': return '- Commit or stash uncommitted changes';
-    case 'tests': return '- Fix failing tests';
-    case 'build': return '- Fix build errors';
-    case 'lint': return '- Fix linting errors';
-    case 'typeCheck': return '- Fix TypeScript errors';
-    case 'requirements': return '- Implement missing requirements';
-  }
-}).join('\n')}
-` : ''}
-```
-
-### JSON Output (for scripting)
-
-```json
-{
-  "approved": ${allPassed},
-  "task": {
-    "id": "${task?.id || 'N/A'}",
-    "title": "${task?.title || 'N/A'}"
-  },
-  "checks": {
-    "gitState": ${JSON.stringify(checks.gitState)},
-    "tests": ${JSON.stringify(checks.tests)},
-    "build": ${JSON.stringify(checks.build)},
-    "lint": ${JSON.stringify(checks.lint)},
-    "typeCheck": ${JSON.stringify(checks.typeCheck)},
-    "requirements": ${JSON.stringify(checks.requirements)}
-  },
-  "failedChecks": ${JSON.stringify(failedChecks)},
-  "summary": "${allPassed ? 'All checks passed' : `Failed: ${failedChecks.join(', ')}`}"
-}
-```
-
-## Examples
-
-```bash
-# Basic validation
-/delivery-approval
-
-# With verbose output
-/delivery-approval --verbose
-
-# For specific task
-/delivery-approval --task-id 142
-
-# Combined
-/delivery-approval --task-id 142 --verbose
-```
-
-## Integration with Workflow
-
-When called from the next-task workflow:
-1. Task context is read from workflow state
-2. Results are written back to workflow state
-3. Workflow continues to ship phase if approved
-
-When called standalone:
-1. Attempts to infer task from commits
-2. Runs all validation checks
-3. Reports results but doesn't modify workflow state
-
-## Success Criteria
-
-- Runs all validation checks (tests, build, lint, types)
-- Checks task requirements if available
-- Provides clear pass/fail determination
-- Shows actionable fixes for failures
-- Works both standalone and in workflow context

package/.cursor/commands/deslop.md

@@ -1,142 +0,0 @@
-
-# /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 = Invoke the deslop-agent agent
-```
-
-### 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) {
-  Invoke the simple-fixer agent
-}
-```
-
-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)