awesome-slash 2.4.2

package/plugins/reality-check/commands/scan.md

@@ -0,0 +1,242 @@
+---
+description: Deep repository analysis to realign project plans with actual code reality
+argument-hint: ""
+allowed-tools: Bash(git:*), Bash(gh:*), Read, Glob, Grep, Task, AskUserQuestion, Write
+---
+
+# /reality-check:scan - Reality Check Scanner
+
+Perform deep repository analysis to identify drift between documented plans and actual implementation.
+
+## Workflow Overview
+
+```
+Settings Check → Parallel Scan (3 agents) → Synthesis → Report
+       ↓                    ↓                   ↓
+   (First-run         (issue-scanner,     (plan-synthesizer
+    setup if           doc-analyzer,        combines all
+    needed)            code-explorer)        findings)
+```
+
+## Phase 1: Settings Check
+
+Check if settings file exists. If not, prompt user to configure via checkboxes.
+
+```javascript
+const rcState = require('${CLAUDE_PLUGIN_ROOT}/lib/state/reality-check-state.js');
+
+// Check for existing settings
+if (!rcState.hasSettings()) {
+  console.log("No settings found. Starting first-run setup...");
+  // → Use AskUserQuestion to gather settings
+}
+```
+
+### First-Run Setup (if no settings exist)
+
+Use AskUserQuestion with checkboxes to gather configuration:
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      header: "Data Sources",
+      question: "Which sources should I scan for project state?",
+      options: [
+        { label: "GitHub Issues & PRs (Recommended)", description: "Scan open issues, PRs, and milestones" },
+        { label: "Documentation files", description: "README, CLAUDE.md, docs/, PLAN.md" },
+        { label: "Linear issues", description: "Requires Linear MCP integration" },
+        { label: "All sources", description: "Comprehensive scan of everything" }
+      ],
+      multiSelect: true
+    },
+    {
+      header: "Scan Depth",
+      question: "How thorough should the analysis be?",
+      options: [
+        { label: "Thorough (Recommended)", description: "Deep analysis, may take longer" },
+        { label: "Quick", description: "Surface-level scan, faster results" },
+        { label: "Medium", description: "Balanced depth and speed" }
+      ],
+      multiSelect: false
+    },
+    {
+      header: "Output",
+      question: "How should I deliver the results?",
+      options: [
+        { label: "Write to file (Recommended)", description: "Save reality-check-report.md" },
+        { label: "Display only", description: "Show in conversation only" },
+        { label: "Both", description: "Save file and show summary" }
+      ],
+      multiSelect: false
+    }
+  ]
+});
+```
+
+After collecting settings, write them:
+
+```javascript
+const settings = mapResponsesToSettings(responses);
+rcState.writeSettings(settings);
+console.log("Settings saved to .claude/reality-check.local.md");
+```
+
+## Phase 2: Initialize Scan
+
+```javascript
+const settings = rcState.readSettings();
+const state = rcState.createState(settings);
+rcState.writeState(state);
+
+rcState.startPhase('parallel-scan');
+
+console.log(`
+## Starting Reality Check Scan
+
+**Scan ID**: ${state.scan.id}
+**Sources**: ${Object.entries(settings.sources).filter(([k,v]) => v).map(([k]) => k).join(', ')}
+**Depth**: ${settings.scan_depth}
+
+Launching parallel scanners...
+`);
+```
+
+## Phase 3: Parallel Agent Execution
+
+Launch three scanner agents in parallel:
+
+```javascript
+// Launch all three scanners simultaneously
+await Promise.all([
+  Task({
+    subagent_type: "reality-check:issue-scanner",
+    prompt: `Scan GitHub issues and PRs. Settings: ${JSON.stringify(settings.sources)}`,
+    run_in_background: false
+  }),
+
+  Task({
+    subagent_type: "reality-check:doc-analyzer",
+    prompt: `Analyze documentation files. Paths: ${settings.sources.docs_paths.join(', ')}`,
+    run_in_background: false
+  }),
+
+  Task({
+    subagent_type: "reality-check:code-explorer",
+    prompt: `Deep codebase exploration. Exclusions: ${settings.exclusions.paths.join(', ')}`,
+    run_in_background: false
+  })
+]);
+
+rcState.completePhase({ scannersCompleted: 3 });
+```
+
+## Phase 4: Synthesis
+
+After all scanners complete, launch the synthesizer:
+
+```javascript
+rcState.startPhase('synthesis');
+
+const state = rcState.readState();
+
+await Task({
+  subagent_type: "reality-check:plan-synthesizer",
+  model: "opus",
+  prompt: `
+Synthesize findings from all scanners:
+
+**Issue Scanner Findings**: ${JSON.stringify(state.agents.issueScanner?.result || {})}
+**Doc Analyzer Findings**: ${JSON.stringify(state.agents.docAnalyzer?.result || {})}
+**Code Explorer Findings**: ${JSON.stringify(state.agents.codeExplorer?.result || {})}
+
+Priority weights: ${JSON.stringify(settings.priority_weights)}
+
+Create a prioritized reality-grounded plan.
+  `
+});
+
+rcState.completePhase({ synthesisComplete: true });
+```
+
+## Phase 5: Report Generation
+
+```javascript
+rcState.startPhase('report-generation');
+
+const state = rcState.readState();
+const settings = rcState.readSettings();
+
+if (settings.output.write_to_file) {
+  // Write report to file
+  const reportPath = settings.output.file_path;
+  await Write({
+    file_path: reportPath,
+    content: state.report.content
+  });
+  console.log(`Report saved to: ${reportPath}`);
+}
+
+if (settings.output.display_summary) {
+  // Display summary
+  console.log(state.report.summary);
+}
+
+rcState.completePhase({ reportGenerated: true });
+```
+
+## Output Format
+
+```markdown
+## Reality Check Complete
+
+**Scan ID**: ${scanId}
+**Duration**: ${duration}
+
+### Summary
+- **Issues scanned**: ${issueCount}
+- **Docs analyzed**: ${docCount}
+- **Code files explored**: ${fileCount}
+
+### Key Findings
+
+**Drift Detected**:
+${driftItems.map(d => `- ${d.description} (${d.severity})`).join('\n')}
+
+**Gaps Identified**:
+${gaps.map(g => `- ${g.description}`).join('\n')}
+
+### Reconstructed Plan
+
+${prioritizedPlan}
+
+---
+Full report: ${reportPath}
+```
+
+## Error Handling
+
+```javascript
+try {
+  // ... scan workflow ...
+} catch (error) {
+  console.log(`
+## Scan Failed
+
+**Error**: ${error.message}
+
+Run \`/reality-check:scan\` to retry.
+  `);
+}
+```
+
+## Success Criteria
+
+- Settings gathered via checkboxes on first run
+- Three scanner agents run in parallel
+- Synthesizer combines all findings
+- Report generated per output settings
+- Drift and gaps clearly identified
+- Prioritized reconstruction plan produced
+
+Begin scan now.

package/plugins/reality-check/commands/set.md

@@ -0,0 +1,203 @@
+---
+description: Configure reality-check settings via interactive checkboxes
+argument-hint: ""
+allowed-tools: Read, Write, AskUserQuestion
+---
+
+# /reality-check:set - Settings Configuration
+
+Configure reality-check plugin settings interactively.
+
+## Overview
+
+This command provides an interactive way to configure the reality-check plugin. Settings are stored in `.claude/reality-check.local.md` and persist across sessions.
+
+## Phase 1: Load Current Settings
+
+```javascript
+const rcState = require('${CLAUDE_PLUGIN_ROOT}/lib/state/reality-check-state.js');
+
+const currentSettings = rcState.readSettings();
+const hasExisting = rcState.hasSettings();
+
+if (hasExisting) {
+  console.log(`
+## Current Settings
+
+**Sources**:
+- GitHub Issues: ${currentSettings.sources.github_issues ? 'Enabled' : 'Disabled'}
+- Linear: ${currentSettings.sources.linear ? 'Enabled' : 'Disabled'}
+- Doc paths: ${currentSettings.sources.docs_paths.join(', ')}
+- Code exploration: ${currentSettings.sources.code_exploration ? 'Enabled' : 'Disabled'}
+
+**Scan Depth**: ${currentSettings.scan_depth}
+
+**Output**:
+- Write to file: ${currentSettings.output.write_to_file ? 'Yes' : 'No'}
+- File path: ${currentSettings.output.file_path}
+- Display summary: ${currentSettings.output.display_summary ? 'Yes' : 'No'}
+
+**Priority Weights**: Security(${currentSettings.priority_weights.security}), Bugs(${currentSettings.priority_weights.bugs}), Features(${currentSettings.priority_weights.features}), Docs(${currentSettings.priority_weights.docs})
+  `);
+}
+```
+
+## Phase 2: Present Configuration Options
+
+Use AskUserQuestion to allow users to modify settings:
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      header: "Data Sources",
+      question: "Which sources should be scanned?",
+      options: [
+        {
+          label: "GitHub Issues & PRs",
+          description: currentSettings.sources.github_issues ? "Currently enabled" : "Currently disabled"
+        },
+        {
+          label: "Documentation files",
+          description: `Paths: ${currentSettings.sources.docs_paths.slice(0, 2).join(', ')}...`
+        },
+        {
+          label: "Linear issues",
+          description: currentSettings.sources.linear ? "Currently enabled" : "Currently disabled"
+        },
+        {
+          label: "Deep code exploration",
+          description: currentSettings.sources.code_exploration ? "Currently enabled" : "Currently disabled"
+        }
+      ],
+      multiSelect: true
+    },
+    {
+      header: "Scan Depth",
+      question: "How thorough should the analysis be?",
+      options: [
+        {
+          label: "Thorough",
+          description: currentSettings.scan_depth === 'thorough' ? "Currently selected" : "Deep analysis"
+        },
+        {
+          label: "Medium",
+          description: currentSettings.scan_depth === 'medium' ? "Currently selected" : "Balanced"
+        },
+        {
+          label: "Quick",
+          description: currentSettings.scan_depth === 'quick' ? "Currently selected" : "Fast scan"
+        }
+      ],
+      multiSelect: false
+    },
+    {
+      header: "Output",
+      question: "How should results be delivered?",
+      options: [
+        {
+          label: "Write to file",
+          description: `Save to ${currentSettings.output.file_path}`
+        },
+        {
+          label: "Display only",
+          description: "Show in conversation without saving"
+        },
+        {
+          label: "Both",
+          description: "Save file and show summary"
+        }
+      ],
+      multiSelect: false
+    }
+  ]
+});
+```
+
+## Phase 3: Process Responses
+
+Map user selections to settings:
+
+```javascript
+function mapResponsesToSettings(responses, currentSettings) {
+  const sources = responses['Data Sources'] || [];
+  const depth = responses['Scan Depth'];
+  const output = responses['Output'];
+
+  return {
+    sources: {
+      github_issues: sources.includes('GitHub Issues & PRs'),
+      linear: sources.includes('Linear issues'),
+      docs_paths: sources.includes('Documentation files')
+        ? currentSettings.sources.docs_paths
+        : [],
+      code_exploration: sources.includes('Deep code exploration')
+    },
+    scan_depth: depth?.toLowerCase() || currentSettings.scan_depth,
+    output: {
+      write_to_file: output === 'Write to file' || output === 'Both',
+      file_path: currentSettings.output.file_path,
+      display_summary: output === 'Display only' || output === 'Both'
+    },
+    priority_weights: currentSettings.priority_weights,
+    exclusions: currentSettings.exclusions
+  };
+}
+```
+
+## Phase 4: Save Settings
+
+```javascript
+const newSettings = mapResponsesToSettings(responses, currentSettings);
+rcState.writeSettings(newSettings);
+
+console.log(`
+## Settings Updated
+
+**Sources**:
+- GitHub Issues: ${newSettings.sources.github_issues ? 'Enabled' : 'Disabled'}
+- Linear: ${newSettings.sources.linear ? 'Enabled' : 'Disabled'}
+- Code exploration: ${newSettings.sources.code_exploration ? 'Enabled' : 'Disabled'}
+
+**Scan Depth**: ${newSettings.scan_depth}
+
+**Output**: ${newSettings.output.write_to_file ? 'File' : ''} ${newSettings.output.display_summary ? '+ Summary' : ''}
+
+Settings saved to \`.claude/reality-check.local.md\`
+
+Run \`/reality-check:scan\` to start a scan with these settings.
+`);
+```
+
+## Advanced Configuration
+
+For advanced settings (priority weights, exclusions, custom doc paths), users can directly edit `.claude/reality-check.local.md`:
+
+```markdown
+## Advanced Settings
+
+To modify priority weights or exclusions, edit the YAML frontmatter in:
+\`.claude/reality-check.local.md\`
+
+Example:
+\`\`\`yaml
+priority_weights:
+  security: 10
+  bugs: 8
+  features: 5
+  docs: 3
+exclusions:
+  paths: ["node_modules/", "dist/", "vendor/"]
+  labels: ["wontfix", "duplicate", "invalid"]
+\`\`\`
+```
+
+## Success Criteria
+
+- Current settings displayed if they exist
+- Interactive checkboxes for common settings
+- Settings saved to .local.md file
+- Clear confirmation of changes
+- Guidance for advanced configuration
+
+Begin settings configuration now.