@slope-dev/cli 0.3.2 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sam Bryers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commands/auto-card.js

@@ -0,0 +1,128 @@
+import { execSync } from 'node:child_process';
+import { writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildScorecard, computeSlope } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+function parseArgs(args) {
+    const result = {};
+    for (const arg of args) {
+        const match = arg.match(/^--(\w[\w-]*)=(.+)$/);
+        if (match)
+            result[match[1]] = match[2];
+    }
+    return result;
+}
+function git(cmd) {
+    try {
+        return execSync(`git ${cmd}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function getCommits(since, branch) {
+    const ref = branch ?? 'HEAD';
+    const sinceArg = since ? `--since="${since}"` : '';
+    const log = git(`log ${ref} ${sinceArg} --format="%H|||%s" --no-merges`);
+    if (!log)
+        return [];
+    return log.split('\n').filter(Boolean).map((line) => {
+        const [hash, subject] = line.split('|||');
+        const stat = git(`diff-tree --no-commit-id --name-only -r ${hash}`);
+        return {
+            hash,
+            subject: subject ?? '',
+            filesChanged: stat ? stat.split('\n').filter(Boolean).length : 0,
+        };
+    });
+}
+function inferTicketKey(subject, index, sprintNumber) {
+    const ticketMatch = subject.match(/\b[A-Z]+-\d+\b/) ?? subject.match(/\bS\d+-\d+\b/i);
+    if (ticketMatch)
+        return ticketMatch[0];
+    return `S${sprintNumber}-${index + 1}`;
+}
+function inferClub(filesChanged) {
+    if (filesChanged >= 10)
+        return 'driver';
+    if (filesChanged >= 5)
+        return 'long_iron';
+    if (filesChanged >= 2)
+        return 'short_iron';
+    return 'wedge';
+}
+function inferSlopeFactors(commits) {
+    const factors = [];
+    const allSubjects = commits.map((c) => c.subject.toLowerCase()).join(' ');
+    if (allSubjects.includes('migration') || allSubjects.includes('schema'))
+        factors.push('schema_migration');
+    if (allSubjects.includes('deploy') || allSubjects.includes('ci') || allSubjects.includes('docker'))
+        factors.push('deployment');
+    if (commits.some((c) => c.filesChanged > 15))
+        factors.push('large_scope');
+    if (allSubjects.includes('refactor'))
+        factors.push('refactor');
+    if (new Set(commits.flatMap((c) => c.subject.match(/packages\/\w+/g) ?? [])).size > 1)
+        factors.push('cross_package');
+    return factors;
+}
+export function autoCardCommand(args) {
+    const opts = parseArgs(args);
+    const config = loadConfig();
+    const sprintNumber = parseInt(opts.sprint ?? '', 10);
+    if (!sprintNumber) {
+        console.error('\nUsage: slope auto-card --sprint=<N> [--since=<date>] [--branch=<ref>] [--theme=<text>] [--dry-run]\n');
+        console.error('  --sprint   Sprint number (required)');
+        console.error('  --since    Git log start date, e.g. "2026-02-20" (optional)');
+        console.error('  --branch   Git ref to scan (default: HEAD)');
+        console.error('  --theme    Sprint theme (default: auto-generated)');
+        console.error('  --dry-run  Print scorecard JSON without writing to disk\n');
+        process.exit(1);
+    }
+    const commits = getCommits(opts.since, opts.branch);
+    if (commits.length === 0) {
+        console.error('\nNo commits found. Try specifying --since or --branch.\n');
+        process.exit(1);
+    }
+    const shots = commits.map((commit, i) => ({
+        ticket_key: inferTicketKey(commit.subject, i, sprintNumber),
+        title: commit.subject,
+        club: inferClub(commit.filesChanged),
+        result: 'in_the_hole',
+        hazards: [],
+        notes: `${commit.filesChanged} files changed`,
+    }));
+    const slopeFactors = inferSlopeFactors(commits);
+    const theme = opts.theme ?? `Sprint ${sprintNumber}`;
+    const card = buildScorecard({
+        sprint_number: sprintNumber,
+        theme,
+        par: shots.length <= 2 ? 3 : shots.length <= 4 ? 4 : 5,
+        slope: computeSlope(slopeFactors),
+        date: new Date().toISOString().split('T')[0],
+        shots,
+    });
+    const output = {
+        ...card,
+        slope_factors: slopeFactors,
+        _auto_generated: true,
+        _commits: commits.length,
+        _note: 'Auto-generated by `slope auto-card`. Review shot results and adjust before filing.',
+    };
+    const json = JSON.stringify(output, null, 2);
+    if (args.includes('--dry-run')) {
+        console.log('\n' + json + '\n');
+        return;
+    }
+    const cwd = process.cwd();
+    const outPath = join(cwd, config.scorecardDir, `sprint-${sprintNumber}.json`);
+    if (existsSync(outPath)) {
+        console.error(`\n  ${outPath} already exists. Use --dry-run to preview, then write manually.\n`);
+        process.exit(1);
+    }
+    writeFileSync(outPath, json + '\n');
+    console.log(`\n  Written to ${outPath}`);
+    console.log(`  ${commits.length} commits → ${shots.length} shots`);
+    console.log(`  Par: ${card.par} | Slope: ${card.slope} (${slopeFactors.join(', ') || 'none'})`);
+    console.log(`\n  ⚠ Review shot results before filing — all default to in_the_hole.\n`);
+}

package/dist/commands/init.js

@@ -1,4 +1,4 @@
-import { writeFileSync, mkdirSync, existsSync, cpSync } from 'node:fs';
+import { writeFileSync, mkdirSync, existsSync, cpSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createConfig } from '../config.js';
@@ -64,70 +64,116 @@ const EXAMPLE_COMMON_ISSUES = {
         },
     ],
 };
+function detectProvider(args) {
+    if (args.includes('--claude-code'))
+        return 'claude-code';
+    if (args.includes('--cursor'))
+        return 'cursor';
+    if (args.includes('--generic'))
+        return 'generic';
+    return null;
+}
+function getTemplatesRoot() {
+    return join(__dirname, '..', '..', '..', '..', 'templates');
+}
+function installClaudeCodeTemplates(cwd) {
+    const templatesRoot = join(getTemplatesRoot(), 'claude-code');
+    const rulesDir = join(cwd, '.claude', 'rules');
+    const hooksDir = join(cwd, '.claude', 'hooks');
+    mkdirSync(rulesDir, { recursive: true });
+    mkdirSync(hooksDir, { recursive: true });
+    const ruleFiles = ['sprint-checklist.md', 'commit-discipline.md', 'review-loop.md'];
+    for (const file of ruleFiles) {
+        const src = join(templatesRoot, 'rules', file);
+        const dest = join(rulesDir, file);
+        if (existsSync(src) && !existsSync(dest)) {
+            cpSync(src, dest);
+            console.log(`  Created ${dest}`);
+        }
+    }
+    const hookFiles = ['pre-merge-check.sh'];
+    for (const file of hookFiles) {
+        const src = join(templatesRoot, 'hooks', file);
+        const dest = join(hooksDir, file);
+        if (existsSync(src) && !existsSync(dest)) {
+            cpSync(src, dest);
+            console.log(`  Created ${dest}`);
+        }
+    }
+    console.log('\n  Claude Code templates installed to .claude/rules/ and .claude/hooks/');
+}
+function installCursorTemplates(cwd) {
+    const templatesRoot = join(getTemplatesRoot(), 'cursor', 'rules');
+    const rulesDir = join(cwd, '.cursor', 'rules');
+    mkdirSync(rulesDir, { recursive: true });
+    try {
+        const files = readdirSync(templatesRoot).filter((f) => f.endsWith('.mdc'));
+        for (const file of files) {
+            const src = join(templatesRoot, file);
+            const dest = join(rulesDir, file);
+            if (!existsSync(dest)) {
+                cpSync(src, dest);
+                console.log(`  Created ${dest}`);
+            }
+        }
+    }
+    catch {
+        console.error('  Warning: Could not find Cursor rule templates');
+    }
+    console.log('\n  Cursor rules installed to .cursor/rules/');
+}
+function installGenericTemplates(cwd) {
+    const templatesRoot = join(getTemplatesRoot(), 'generic');
+    const dest = join(cwd, 'SLOPE-CHECKLIST.md');
+    const src = join(templatesRoot, 'SLOPE-CHECKLIST.md');
+    if (existsSync(src) && !existsSync(dest)) {
+        cpSync(src, dest);
+        console.log(`  Created ${dest}`);
+    }
+    console.log('\n  Generic SLOPE checklist installed.');
+}
 export function initCommand(args) {
     const cwd = process.cwd();
-    const claudeCode = args.includes('--claude-code');
-    // Create .slope directory and config
+    const provider = detectProvider(args);
     const configPath = createConfig(cwd);
     console.log(`  Created ${configPath}`);
-    // Create scorecard directory
     const scorecardDir = join(cwd, 'docs', 'retros');
     if (!existsSync(scorecardDir)) {
         mkdirSync(scorecardDir, { recursive: true });
         console.log(`  Created ${scorecardDir}/`);
     }
-    // Write example scorecard
     const examplePath = join(scorecardDir, 'sprint-1.json');
     if (!existsSync(examplePath)) {
         writeFileSync(examplePath, JSON.stringify(EXAMPLE_SCORECARD, null, 2) + '\n');
         console.log(`  Created ${examplePath}`);
     }
-    // Write example common-issues.json
     const commonIssuesPath = join(cwd, '.slope', 'common-issues.json');
     if (!existsSync(commonIssuesPath)) {
         writeFileSync(commonIssuesPath, JSON.stringify(EXAMPLE_COMMON_ISSUES, null, 2) + '\n');
         console.log(`  Created ${commonIssuesPath}`);
     }
-    // Write example sessions.json
     const sessionsPath = join(cwd, '.slope', 'sessions.json');
     if (!existsSync(sessionsPath)) {
         writeFileSync(sessionsPath, JSON.stringify({ sessions: [] }, null, 2) + '\n');
         console.log(`  Created ${sessionsPath}`);
     }
-    // Write empty claims.json
     const claimsPath = join(cwd, '.slope', 'claims.json');
     if (!existsSync(claimsPath)) {
         writeFileSync(claimsPath, JSON.stringify({ claims: [] }, null, 2) + '\n');
         console.log(`  Created ${claimsPath}`);
     }
-    // Claude Code templates
-    if (claudeCode) {
-        const templatesRoot = join(__dirname, '..', '..', '..', '..', 'templates', 'claude-code');
-        const rulesDir = join(cwd, '.claude', 'rules');
-        const hooksDir = join(cwd, '.claude', 'hooks');
-        mkdirSync(rulesDir, { recursive: true });
-        mkdirSync(hooksDir, { recursive: true });
-        // Copy rule templates
-        const ruleFiles = ['sprint-checklist.md', 'commit-discipline.md', 'review-loop.md'];
-        for (const file of ruleFiles) {
-            const src = join(templatesRoot, 'rules', file);
-            const dest = join(rulesDir, file);
-            if (existsSync(src) && !existsSync(dest)) {
-                cpSync(src, dest);
-                console.log(`  Created ${dest}`);
-            }
-        }
-        // Copy hook templates
-        const hookFiles = ['pre-merge-check.sh'];
-        for (const file of hookFiles) {
-            const src = join(templatesRoot, 'hooks', file);
-            const dest = join(hooksDir, file);
-            if (existsSync(src) && !existsSync(dest)) {
-                cpSync(src, dest);
-                console.log(`  Created ${dest}`);
-            }
-        }
-        console.log('\n  Claude Code templates installed to .claude/rules/ and .claude/hooks/');
+    switch (provider) {
+        case 'claude-code':
+            installClaudeCodeTemplates(cwd);
+            break;
+        case 'cursor':
+            installCursorTemplates(cwd);
+            break;
+        case 'generic':
+            installGenericTemplates(cwd);
+            break;
+        default:
+            break;
     }
     console.log('\nSLOPE initialized. Try:');
     console.log('  slope card');

package/dist/commands/next.js

@@ -0,0 +1,27 @@
+import { loadConfig } from '../config.js';
+import { resolveCurrentSprint, detectLatestSprint } from '../loader.js';
+export function nextCommand() {
+    const config = loadConfig();
+    const cwd = process.cwd();
+    const latest = detectLatestSprint(config, cwd);
+    const next = resolveCurrentSprint(config, cwd);
+    console.log('');
+    if (latest === 0) {
+        console.log('  No scorecards found. Next sprint: S1');
+    }
+    else {
+        console.log(`  Latest scorecard: S${latest}`);
+        console.log(`  Next sprint: S${next}`);
+    }
+    if (config.currentSprint) {
+        console.log(`  (set explicitly in .slope/config.json)`);
+    }
+    else {
+        console.log(`  (auto-detected from scorecards)`);
+    }
+    console.log('');
+    console.log('  Quick start:');
+    console.log(`    slope briefing --sprint=${next}`);
+    console.log(`    slope auto-card --sprint=${next} --since="$(date -d yesterday +%Y-%m-%d)"`);
+    console.log('');
+}

package/dist/index.js

@@ -24,6 +24,9 @@ import { classifyCommand } from './commands/classify.js';
 import { claimCommand } from './commands/claim.js';
 import { releaseCommand } from './commands/release.js';
 import { statusCommand } from './commands/status.js';
+import { tournamentCommand } from './commands/tournament.js';
+import { autoCardCommand } from './commands/auto-card.js';
+import { nextCommand } from './commands/next.js';
 const subcommand = process.argv[2];
 switch (subcommand) {
     case 'init':
@@ -72,12 +75,21 @@ switch (subcommand) {
             process.exit(1);
         });
         break;
+    case 'tournament':
+        tournamentCommand(process.argv.slice(3));
+        break;
+    case 'auto-card':
+        autoCardCommand(process.argv.slice(3));
+        break;
+    case 'next':
+        nextCommand();
+        break;
     default:
         console.log(`
 SLOPE CLI — Sprint Lifecycle & Operational Performance Engine
 
 Usage:
-  slope init [--claude-code]                Initialize .slope/ directory
+  slope init [--claude-code|--cursor|--generic]  Initialize .slope/ directory
   slope card                                Show handicap card
   slope validate [path]                     Validate scorecard(s)
   slope review [path] [--plain]             Format sprint review markdown
@@ -88,9 +100,13 @@ Usage:
   slope release --id=<id>                   Release a claim by ID
   slope release --target=<t> [--player=<p>] Release a claim by target
   slope status [--sprint=N]                 Show sprint course status + conflicts
+  slope tournament --id=<id> --sprints=N..M Build tournament review from sprints
+  slope auto-card --sprint=<N> [options]    Generate scorecard from git commits
+  slope next                                Show next sprint number (auto-detect)
 
 Examples:
   slope init                                Create .slope/ with config + example scorecard
+  slope init --cursor                       Also install Cursor IDE rules
   slope init --claude-code                  Also install Claude Code rules + hooks
   slope card                                Show handicap across all scorecards
   slope validate docs/retros/sprint-1.json  Validate a specific scorecard

package/dist/loader.js

@@ -39,6 +39,25 @@ export function loadScorecards(config, cwd = process.cwd()) {
     }
     return scorecards;
 }
+/**
+ * Detect the latest sprint number from existing scorecards.
+ * Returns 0 if no scorecards are found.
+ */
+export function detectLatestSprint(config, cwd = process.cwd()) {
+    const cards = loadScorecards(config, cwd);
+    if (cards.length === 0)
+        return 0;
+    return Math.max(...cards.map((c) => c.sprint_number));
+}
+/**
+ * Resolve the current sprint number: explicit config > auto-detect + 1.
+ */
+export function resolveCurrentSprint(config, cwd = process.cwd()) {
+    if (config.currentSprint)
+        return config.currentSprint;
+    const latest = detectLatestSprint(config, cwd);
+    return latest + 1;
+}
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/package.json

@@ -1,18 +1,13 @@
 {
   "name": "@slope-dev/cli",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "SLOPE CLI — Sprint Lifecycle & Operational Performance Engine",
   "type": "module",
   "bin": {
     "slope": "./dist/index.js"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
-    "@slope-dev/core": "^0.3.2"
+    "@slope-dev/core": "0.3.3"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
@@ -40,5 +35,10 @@
   ],
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}