agentsys 5.3.0 → 5.3.2

package/.kiro/steering/delivery-approval.md

@@ -0,0 +1,339 @@
+---
+inclusion: manual
+name: "delivery-approval"
+description: "Use when user asks to \"validate delivery\", \"approve for shipping\", \"check if ready to ship\", \"verify task completion\". Autonomous validation that tests pass, build succeeds, and requirements are met."
+---
+
+# /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/.kiro/steering/deslop.md

@@ -0,0 +1,149 @@
+---
+inclusion: manual
+name: "deslop"
+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."
+---
+
+# /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 = Delegate to the `deslop-agent` subagent:
+> Scan for AI slop patterns.
+```
+
+### 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) {
+  Delegate to the `simple-fixer` subagent:
+> Apply these slop fixes:
+}
+```
+
+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)