@slope-dev/cli 0.1.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/briefing.js

@@ -0,0 +1,49 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { formatBriefing } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+export function briefingCommand(args) {
+    const config = loadConfig();
+    const cwd = process.cwd();
+    const scorecards = loadScorecards(config, cwd);
+    // Load common-issues
+    let commonIssues;
+    try {
+        commonIssues = JSON.parse(readFileSync(join(cwd, config.commonIssuesPath), 'utf8'));
+    }
+    catch {
+        commonIssues = { recurring_patterns: [] };
+    }
+    // Load last session
+    let lastSession;
+    try {
+        const sessionsData = JSON.parse(readFileSync(join(cwd, config.sessionsPath), 'utf8'));
+        const sessions = sessionsData.sessions;
+        if (sessions && sessions.length > 0) {
+            lastSession = sessions[sessions.length - 1];
+        }
+    }
+    catch { /* skip */ }
+    // Parse args
+    const categories = [];
+    const keywords = [];
+    let includeTraining = true;
+    for (const arg of args) {
+        if (arg.startsWith('--categories=')) {
+            categories.push(...arg.slice('--categories='.length).split(',').map(s => s.trim()).filter(Boolean));
+        }
+        else if (arg.startsWith('--keywords=')) {
+            keywords.push(...arg.slice('--keywords='.length).split(',').map(s => s.trim()).filter(Boolean));
+        }
+        else if (arg === '--no-training') {
+            includeTraining = false;
+        }
+    }
+    const filter = (categories.length > 0 || keywords.length > 0)
+        ? { categories: categories.length > 0 ? categories : undefined, keywords: keywords.length > 0 ? keywords : undefined }
+        : undefined;
+    const output = formatBriefing({ scorecards, commonIssues, lastSession, filter, includeTraining });
+    console.log('');
+    console.log(output);
+}

package/dist/commands/card.js

@@ -0,0 +1,50 @@
+import { computeHandicapCard } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+export function cardCommand() {
+    const config = loadConfig();
+    const scorecards = loadScorecards(config);
+    if (scorecards.length === 0) {
+        console.log('\nNo scorecards found. Run `slope init` to create an example.\n');
+        process.exit(0);
+    }
+    const card = computeHandicapCard(scorecards);
+    const pad = (s, w) => String(s).padStart(w);
+    const pct = (n) => n.toFixed(1) + '%';
+    const minSprint = config.minSprint;
+    console.log(`\nSLOPE Handicap Card (${scorecards.length} scorecard${scorecards.length === 1 ? '' : 's'}, Sprint ${minSprint}+)`);
+    console.log('\u2501'.repeat(47));
+    console.log('');
+    console.log(`${'Stat'.padEnd(20)}${'Last 5'.padStart(9)}${'Last 10'.padStart(10)}${'All-time'.padStart(10)}`);
+    console.log('\u2500'.repeat(49));
+    const rows = [
+        ['Handicap', w => `+${w.handicap.toFixed(1)}`],
+        ['Fairways', w => pct(w.fairway_pct)],
+        ['GIR', w => pct(w.gir_pct)],
+        ['Avg putts/hole', w => w.avg_putts.toFixed(1)],
+        ['Penalties/round', w => w.penalties_per_round.toFixed(1)],
+        ['Mulligans', w => String(w.mulligans)],
+        ['Gimmes', w => String(w.gimmes)],
+    ];
+    for (const [label, fn] of rows) {
+        console.log(`${label.padEnd(20)}${pad(fn(card.last_5), 9)}${pad(fn(card.last_10), 10)}${pad(fn(card.all_time), 10)}`);
+    }
+    // Miss pattern summary
+    const allMiss = card.all_time.miss_pattern;
+    const totalMisses = allMiss.long + allMiss.short + allMiss.left + allMiss.right;
+    console.log('');
+    if (totalMisses === 0) {
+        console.log('Miss Pattern: No misses recorded.');
+    }
+    else {
+        const dirs = ['long', 'short', 'left', 'right']
+            .filter(d => allMiss[d] > 0)
+            .map(d => `${d}: ${allMiss[d]}`)
+            .join(', ');
+        console.log(`Miss Pattern: ${dirs} (${totalMisses} total)`);
+    }
+    if (scorecards.length < 5) {
+        console.log(`\nNote: Only ${scorecards.length} scorecard${scorecards.length === 1 ? '' : 's'} \u2014 windows fill at Sprint ${minSprint + 5 - scorecards.length}.`);
+    }
+    console.log('');
+}

package/dist/commands/classify.js

@@ -0,0 +1,69 @@
+import { classifyShot } from '@slope-dev/core';
+export function classifyCommand(args) {
+    let scope;
+    let modified;
+    let tests;
+    let reverts;
+    let hazards;
+    for (const arg of args) {
+        if (arg.startsWith('--scope='))
+            scope = arg.slice('--scope='.length);
+        else if (arg.startsWith('--modified='))
+            modified = arg.slice('--modified='.length);
+        else if (arg.startsWith('--tests='))
+            tests = arg.slice('--tests='.length);
+        else if (arg.startsWith('--reverts='))
+            reverts = arg.slice('--reverts='.length);
+        else if (arg.startsWith('--hazards='))
+            hazards = arg.slice('--hazards='.length);
+    }
+    if (!scope || !modified || !tests || reverts == null) {
+        console.error('\nUsage: slope classify --scope="a.ts,b.ts" --modified="a.ts,b.ts" --tests=pass|fail|partial --reverts=N [--hazards=N]\n');
+        process.exit(1);
+        return; // unreachable, helps TS narrow
+    }
+    const validTests = ['pass', 'fail', 'partial'];
+    if (!validTests.includes(tests)) {
+        console.error(`\nInvalid --tests value "${tests}". Must be one of: ${validTests.join(', ')}\n`);
+        process.exit(1);
+        return;
+    }
+    const scopePaths = scope.split(',').map((s) => s.trim()).filter(Boolean);
+    const modifiedFiles = modified.split(',').map((s) => s.trim()).filter(Boolean);
+    const revertCount = parseInt(reverts, 10) || 0;
+    const hazardCount = parseInt(hazards ?? '0', 10) || 0;
+    // Build test_results
+    const testResults = [];
+    if (tests === 'pass') {
+        testResults.push({ suite: 'all', passed: true, first_run: true });
+    }
+    else if (tests === 'fail') {
+        testResults.push({ suite: 'all', passed: false, first_run: true });
+    }
+    else {
+        testResults.push({ suite: 'unit', passed: true, first_run: true });
+        testResults.push({ suite: 'integration', passed: false, first_run: true });
+    }
+    // Build hazards_encountered
+    const hazardsEncountered = Array.from({ length: hazardCount }, (_, i) => ({
+        type: 'rough',
+        description: `Hazard ${i + 1}`,
+    }));
+    const trace = {
+        planned_scope_paths: scopePaths,
+        modified_files: modifiedFiles,
+        test_results: testResults,
+        reverts: revertCount,
+        elapsed_minutes: 0,
+        hazards_encountered: hazardsEncountered,
+    };
+    const result = classifyShot(trace);
+    console.log('');
+    console.log('SHOT CLASSIFICATION');
+    console.log('\u2550'.repeat(40));
+    console.log(`  Result:         ${result.result}`);
+    console.log(`  Miss direction: ${result.miss_direction ?? 'none'}`);
+    console.log(`  Confidence:     ${Math.round(result.confidence * 100)}%`);
+    console.log(`  Reasoning:      ${result.reasoning}`);
+    console.log('');
+}

package/dist/commands/init.js

@@ -0,0 +1,130 @@
+import { writeFileSync, mkdirSync, existsSync, cpSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createConfig } from '../config.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const EXAMPLE_SCORECARD = {
+    sprint_number: 1,
+    theme: 'Example Sprint',
+    par: 3,
+    slope: 0,
+    score: 3,
+    score_label: 'par',
+    date: new Date().toISOString().split('T')[0],
+    shots: [
+        {
+            ticket_key: 'S1-1',
+            title: 'Set up project',
+            club: 'short_iron',
+            result: 'green',
+            hazards: [],
+            notes: 'Clean setup',
+        },
+        {
+            ticket_key: 'S1-2',
+            title: 'Add core feature',
+            club: 'short_iron',
+            result: 'in_the_hole',
+            hazards: [],
+        },
+        {
+            ticket_key: 'S1-3',
+            title: 'Write tests',
+            club: 'wedge',
+            result: 'green',
+            hazards: [{ type: 'rough', description: 'Flaky test environment' }],
+        },
+    ],
+    conditions: [],
+    special_plays: [],
+    stats: {
+        fairways_hit: 3,
+        fairways_total: 3,
+        greens_in_regulation: 3,
+        greens_total: 3,
+        putts: 0,
+        penalties: 0,
+        hazards_hit: 1,
+        miss_directions: { long: 0, short: 0, left: 0, right: 0 },
+    },
+    yardage_book_updates: [],
+    bunker_locations: [],
+    course_management_notes: ['This is an example scorecard — replace with your own sprint data.'],
+};
+const EXAMPLE_COMMON_ISSUES = {
+    recurring_patterns: [
+        {
+            id: 1,
+            title: 'Example pattern',
+            category: 'general',
+            sprints_hit: [1],
+            gotcha_refs: [],
+            description: 'This is an example recurring pattern. Replace with your own.',
+            prevention: 'Add your prevention strategy here.',
+        },
+    ],
+};
+export function initCommand(args) {
+    const cwd = process.cwd();
+    const claudeCode = args.includes('--claude-code');
+    // Create .slope directory and config
+    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}`);
+    }
+    // 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/');
+    }
+    console.log('\nSLOPE initialized. Try:');
+    console.log('  slope card');
+    console.log('  slope validate');
+    console.log('');
+}

package/dist/commands/plan.js

@@ -0,0 +1,53 @@
+import { recommendClub, computeHandicapCard, computeDispersion, generateTrainingPlan, hazardBriefing, formatAdvisorReport, } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+export function planCommand(args) {
+    let complexity;
+    const slopeFactors = [];
+    const areas = [];
+    for (const arg of args) {
+        if (arg.startsWith('--complexity=')) {
+            complexity = arg.slice('--complexity='.length);
+        }
+        else if (arg.startsWith('--slope-factors=')) {
+            slopeFactors.push(...arg.slice('--slope-factors='.length).split(',').map(s => s.trim()).filter(Boolean));
+        }
+        else if (arg.startsWith('--areas=')) {
+            areas.push(...arg.slice('--areas='.length).split(',').map(s => s.trim()).filter(Boolean));
+        }
+    }
+    if (!complexity) {
+        console.error('\nUsage: slope plan --complexity=<trivial|small|medium|large> [--slope-factors=a,b] [--areas=x,y]\n');
+        process.exit(1);
+        return;
+    }
+    const validComplexities = ['trivial', 'small', 'medium', 'large'];
+    if (!validComplexities.includes(complexity)) {
+        console.error(`\nInvalid complexity "${complexity}". Must be one of: ${validComplexities.join(', ')}\n`);
+        process.exit(1);
+        return;
+    }
+    const config = loadConfig();
+    const scorecards = loadScorecards(config);
+    // Club recommendation
+    const clubRec = recommendClub({
+        ticketComplexity: complexity,
+        scorecards,
+        slopeFactors,
+    });
+    // Training plan
+    let trainingPlan = [];
+    if (scorecards.length > 0) {
+        const handicap = computeHandicapCard(scorecards);
+        const dispersion = computeDispersion(scorecards);
+        trainingPlan = generateTrainingPlan({ handicap, dispersion, recentScorecards: scorecards });
+    }
+    // Hazard warnings
+    let hazardWarnings = [];
+    if (areas.length > 0 && scorecards.length > 0) {
+        hazardWarnings = hazardBriefing({ areas, scorecards });
+    }
+    const report = formatAdvisorReport({ clubRecommendation: clubRec, trainingPlan, hazardWarnings });
+    console.log('');
+    console.log(report);
+}

package/dist/commands/review.js

@@ -0,0 +1,46 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { formatSprintReview } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+export function reviewCommand(path, mode) {
+    const config = loadConfig();
+    const cwd = process.cwd();
+    if (!path) {
+        // Default to latest scorecard
+        const dir = join(cwd, config.scorecardDir);
+        const patternParts = config.scorecardPattern.split('*');
+        const prefix = patternParts[0] ?? '';
+        const suffix = patternParts[1] ?? '';
+        const regex = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\d+)${suffix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
+        try {
+            const files = readdirSync(dir)
+                .filter((f) => {
+                const m = f.match(regex);
+                return m && parseInt(m[1], 10) >= config.minSprint;
+            })
+                .sort();
+            if (files.length === 0) {
+                console.log('\nNo scorecards found.\n');
+                process.exit(1);
+            }
+            path = join(dir, files[files.length - 1]);
+        }
+        catch {
+            console.log('\nScorecard directory not found.\n');
+            process.exit(1);
+        }
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        console.error(`\nFailed to parse ${path}\n`);
+        process.exit(1);
+    }
+    const card = { ...raw, sprint_number: raw.sprint_number ?? raw.sprint };
+    const reviewMode = mode === 'plain' ? 'plain' : 'technical';
+    const review = formatSprintReview(card, undefined, undefined, reviewMode);
+    console.log('');
+    console.log(review);
+}

package/dist/commands/validate.js

@@ -0,0 +1,73 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateScorecard } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+export function validateCommand(path) {
+    const config = loadConfig();
+    const files = [];
+    if (path) {
+        files.push(path);
+    }
+    else {
+        // Validate all scorecards matching config
+        const dir = join(process.cwd(), config.scorecardDir);
+        const patternParts = config.scorecardPattern.split('*');
+        const prefix = patternParts[0] ?? '';
+        const suffix = patternParts[1] ?? '';
+        const regex = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\d+)${suffix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
+        try {
+            const dirFiles = readdirSync(dir)
+                .filter((f) => {
+                const m = f.match(regex);
+                return m && parseInt(m[1], 10) >= config.minSprint;
+            })
+                .sort();
+            for (const f of dirFiles) {
+                files.push(join(dir, f));
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    if (files.length === 0) {
+        console.log('\nNo scorecards found to validate.\n');
+        process.exit(0);
+    }
+    let allValid = true;
+    for (const file of files) {
+        let raw;
+        try {
+            raw = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch {
+            console.log(`\n\u2717 ${file}: Failed to parse JSON`);
+            allValid = false;
+            continue;
+        }
+        const card = { ...raw, sprint_number: raw.sprint_number ?? raw.sprint };
+        const result = validateScorecard(card);
+        const sprintLabel = card.sprint_number ? `Sprint ${card.sprint_number}` : file;
+        if (result.valid && result.warnings.length === 0) {
+            console.log(`\u2713 ${sprintLabel}: Valid (no errors, no warnings)`);
+        }
+        else if (result.valid) {
+            console.log(`\u2713 ${sprintLabel}: Valid (${result.warnings.length} warning${result.warnings.length === 1 ? '' : 's'})`);
+            for (const w of result.warnings) {
+                console.log(`  \u26A0 [${w.code}] ${w.message}`);
+            }
+        }
+        else {
+            console.log(`\u2717 ${sprintLabel}: INVALID (${result.errors.length} error${result.errors.length === 1 ? '' : 's'}, ${result.warnings.length} warning${result.warnings.length === 1 ? '' : 's'})`);
+            for (const e of result.errors) {
+                console.log(`  \u2717 [${e.code}] ${e.message}${e.field ? ` (${e.field})` : ''}`);
+            }
+            for (const w of result.warnings) {
+                console.log(`  \u26A0 [${w.code}] ${w.message}`);
+            }
+            allValid = false;
+        }
+    }
+    console.log('');
+    process.exit(allValid ? 0 : 1);
+}

package/dist/config.js

@@ -0,0 +1,36 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+const DEFAULT_CONFIG = {
+    scorecardDir: 'docs/retros',
+    scorecardPattern: 'sprint-*.json',
+    minSprint: 1,
+    commonIssuesPath: '.slope/common-issues.json',
+    sessionsPath: '.slope/sessions.json',
+};
+const CONFIG_DIR = '.slope';
+const CONFIG_FILE = 'config.json';
+export function loadConfig(cwd = process.cwd()) {
+    const configPath = join(cwd, CONFIG_DIR, CONFIG_FILE);
+    if (!existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(configPath, 'utf8'));
+        return { ...DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function createConfig(cwd = process.cwd()) {
+    const dir = join(cwd, CONFIG_DIR);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const configPath = join(dir, CONFIG_FILE);
+    writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+    return configPath;
+}
+export function resolveConfigPath(config, relativePath, cwd = process.cwd()) {
+    return join(cwd, relativePath);
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * SLOPE CLI — Sprint Lifecycle & Operational Performance Engine
+ *
+ * Usage:
+ *   slope init                              Initialize .slope/ directory
+ *   slope card                              Display handicap card
+ *   slope validate [path]                   Validate scorecard(s)
+ *   slope review [path] [--plain]           Format sprint review
+ *   slope briefing [options]                Pre-round briefing
+ *   slope plan --complexity=<level>         Pre-shot advisor
+ *   slope classify --scope=... ...          Classify a shot
+ */
+import { initCommand } from './commands/init.js';
+import { cardCommand } from './commands/card.js';
+import { validateCommand } from './commands/validate.js';
+import { reviewCommand } from './commands/review.js';
+import { briefingCommand } from './commands/briefing.js';
+import { planCommand } from './commands/plan.js';
+import { classifyCommand } from './commands/classify.js';
+const subcommand = process.argv[2];
+switch (subcommand) {
+    case 'init':
+        initCommand(process.argv.slice(3));
+        break;
+    case 'card':
+        cardCommand();
+        break;
+    case 'validate':
+        validateCommand(process.argv[3]);
+        break;
+    case 'review': {
+        const reviewArgs = process.argv.slice(3);
+        const plainFlag = reviewArgs.includes('--plain');
+        const path = reviewArgs.find((a) => !a.startsWith('--'));
+        reviewCommand(path, plainFlag ? 'plain' : undefined);
+        break;
+    }
+    case 'briefing':
+        briefingCommand(process.argv.slice(3));
+        break;
+    case 'plan':
+        planCommand(process.argv.slice(3));
+        break;
+    case 'classify':
+        classifyCommand(process.argv.slice(3));
+        break;
+    default:
+        console.log(`
+SLOPE CLI — Sprint Lifecycle & Operational Performance Engine
+
+Usage:
+  slope init [--claude-code]                Initialize .slope/ directory
+  slope card                                Show handicap card
+  slope validate [path]                     Validate scorecard(s)
+  slope review [path] [--plain]             Format sprint review markdown
+  slope briefing [options]                  Pre-round briefing
+  slope plan --complexity=<level>           Pre-shot advisor (club + training + hazards)
+  slope classify --scope=... ...            Classify a shot from execution trace
+
+Examples:
+  slope init                                Create .slope/ with config + example scorecard
+  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
+  slope validate                            Validate all scorecards
+  slope review                              Review the latest scorecard
+  slope review --plain                      Non-technical sprint review
+  slope briefing                            Full briefing (top 10 recent gotchas)
+  slope briefing --categories=testing       Filter by category
+  slope briefing --keywords=migration       Filter by keyword
+  slope plan --complexity=medium            Club recommendation for medium ticket
+  slope plan --complexity=large --areas=db  Include hazard warnings for db area
+  slope classify --scope="a.ts" --modified="a.ts" --tests=pass --reverts=0
+`);
+        process.exit(subcommand ? 1 : 0);
+}

package/dist/loader.js

@@ -0,0 +1,44 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Load SLOPE scorecards from the configured directory.
+ * Filters by minSprint and normalizes sprint_number.
+ */
+export function loadScorecards(config, cwd = process.cwd()) {
+    const dir = join(cwd, config.scorecardDir);
+    if (!existsSync(dir)) {
+        return [];
+    }
+    // Build regex from pattern (e.g. "sprint-*.json" → /^sprint-(\d+)\.json$/)
+    const patternParts = config.scorecardPattern.split('*');
+    const prefix = patternParts[0] ?? '';
+    const suffix = patternParts[1] ?? '';
+    const regex = new RegExp(`^${escapeRegex(prefix)}(\\d+)${escapeRegex(suffix)}$`);
+    const files = readdirSync(dir)
+        .filter((f) => regex.test(f))
+        .sort();
+    const scorecards = [];
+    for (const file of files) {
+        const match = file.match(regex);
+        if (!match)
+            continue;
+        const num = parseInt(match[1], 10);
+        if (num < config.minSprint)
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(join(dir, file), 'utf8'));
+            const card = {
+                ...raw,
+                sprint_number: raw.sprint_number ?? raw.sprint,
+            };
+            scorecards.push(card);
+        }
+        catch {
+            console.error(`  Warning: Could not parse ${file}, skipping`);
+        }
+    }
+    return scorecards;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@slope-dev/cli",
+  "version": "0.1.0",
+  "description": "SLOPE CLI — Sprint Lifecycle & Operational Performance Engine",
+  "type": "module",
+  "bin": {
+    "slope": "./dist/index.js"
+  },
+  "dependencies": {
+    "@slope-dev/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/srbryers/slope.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "slope",
+    "sprint",
+    "scoring",
+    "cli",
+    "retro"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}