@slope-dev/cli 0.1.0 → 0.2.0

package/dist/commands/briefing.js

@@ -3,7 +3,8 @@ 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) {
+import { createRegistry } from '../registries/index.js';
+export async function briefingCommand(args) {
     const config = loadConfig();
     const cwd = process.cwd();
     const scorecards = loadScorecards(config, cwd);
@@ -29,6 +30,7 @@ export function briefingCommand(args) {
     const categories = [];
     const keywords = [];
     let includeTraining = true;
+    let sprintFlag;
     for (const arg of args) {
         if (arg.startsWith('--categories=')) {
             categories.push(...arg.slice('--categories='.length).split(',').map(s => s.trim()).filter(Boolean));
@@ -36,14 +38,39 @@ export function briefingCommand(args) {
         else if (arg.startsWith('--keywords=')) {
             keywords.push(...arg.slice('--keywords='.length).split(',').map(s => s.trim()).filter(Boolean));
         }
+        else if (arg.startsWith('--sprint=')) {
+            sprintFlag = parseInt(arg.slice('--sprint='.length), 10);
+        }
         else if (arg === '--no-training') {
             includeTraining = false;
         }
     }
+    // Resolve sprint number
+    let sprintNumber;
+    if (sprintFlag) {
+        sprintNumber = sprintFlag;
+    }
+    else if (config.currentSprint) {
+        sprintNumber = config.currentSprint;
+    }
+    else if (scorecards.length > 0) {
+        const maxSprint = Math.max(...scorecards.map(s => s.sprint_number));
+        sprintNumber = maxSprint + 1;
+    }
+    else {
+        sprintNumber = 1;
+    }
+    // Load claims
+    let claims = [];
+    try {
+        const registry = createRegistry(config, cwd);
+        claims = await registry.list(sprintNumber);
+    }
+    catch { /* skip — claims are optional */ }
     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 });
+    const output = formatBriefing({ scorecards, commonIssues, lastSession, filter, includeTraining, claims });
     console.log('');
     console.log(output);
 }

package/dist/commands/claim.js

@@ -0,0 +1,99 @@
+import { checkConflicts } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+import { createRegistry } from '../registries/index.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 resolveSprint(flags, cwd) {
+    if (flags.sprint)
+        return parseInt(flags.sprint, 10);
+    const config = loadConfig(cwd);
+    if (config.currentSprint)
+        return config.currentSprint;
+    const scorecards = loadScorecards(config, cwd);
+    if (scorecards.length === 0)
+        return 1;
+    const maxSprint = Math.max(...scorecards.map(s => s.sprint_number));
+    return maxSprint + 1;
+}
+export async function claimCommand(args) {
+    const flags = parseArgs(args);
+    const force = args.includes('--force');
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    const registry = createRegistry(config, cwd);
+    const target = flags.target;
+    if (!target) {
+        console.error('Error: --target is required');
+        process.exit(1);
+    }
+    const scope = flags.scope || 'ticket';
+    const player = flags.player || process.env.USER || 'unknown';
+    const sprintNumber = resolveSprint(flags, cwd);
+    // Preflight conflict check: build a temporary claim and test against existing claims
+    const existingClaims = await registry.list(sprintNumber);
+    const tempClaim = {
+        id: '__pending__',
+        sprint_number: sprintNumber,
+        player,
+        target,
+        scope,
+        claimed_at: new Date().toISOString(),
+        ...(flags.notes ? { notes: flags.notes } : {}),
+    };
+    const conflicts = checkConflicts([...existingClaims, tempClaim]);
+    const overlaps = conflicts.filter(c => c.severity === 'overlap');
+    const adjacents = conflicts.filter(c => c.severity === 'adjacent');
+    // Block on overlaps unless --force
+    if (overlaps.length > 0 && !force) {
+        console.error(`\nClaim blocked — overlap conflict(s) detected:`);
+        for (const c of overlaps) {
+            console.error(`  [!!] ${c.reason}`);
+        }
+        console.error(`\nUse --force to override.`);
+        process.exit(1);
+    }
+    // Register the claim
+    const claim = await registry.claim({
+        sprint_number: sprintNumber,
+        player,
+        target,
+        scope,
+        ...(flags.notes ? { notes: flags.notes } : {}),
+    });
+    // Forced overlap warning
+    if (overlaps.length > 0 && force) {
+        console.log(`\nClaim registered (forced override):`);
+        console.log(`  Warning: ${overlaps.length} overlap conflict(s) overridden:`);
+        for (const c of overlaps) {
+            console.log(`    [!!] ${c.reason}`);
+        }
+    }
+    else {
+        console.log(`\nClaim registered:`);
+    }
+    console.log(`  ID:     ${claim.id}`);
+    console.log(`  Sprint: ${claim.sprint_number}`);
+    console.log(`  Player: ${claim.player}`);
+    console.log(`  Target: ${claim.target} (${claim.scope})`);
+    if (claim.notes)
+        console.log(`  Notes:  ${claim.notes}`);
+    // Adjacent conflicts are informational only
+    if (adjacents.length > 0) {
+        console.log(`\n  Note: ${adjacents.length} adjacent conflict(s):`);
+        for (const c of adjacents) {
+            console.log(`    [~] ${c.reason}`);
+        }
+    }
+    if (overlaps.length === 0 && adjacents.length === 0) {
+        console.log(`\n  No conflicts detected.`);
+    }
+    console.log('');
+}

package/dist/commands/init.js

@@ -94,6 +94,12 @@ export function initCommand(args) {
         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');

package/dist/commands/release.js

@@ -0,0 +1,64 @@
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+import { createRegistry } from '../registries/index.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 resolveSprintRange(flags, cwd) {
+    const config = loadConfig(cwd);
+    if (flags.sprint)
+        return [parseInt(flags.sprint, 10)];
+    if (config.currentSprint)
+        return [config.currentSprint];
+    const scorecards = loadScorecards(config, cwd);
+    if (scorecards.length === 0)
+        return [1];
+    const maxSprint = Math.max(...scorecards.map(s => s.sprint_number));
+    // Check the current and next sprint (most likely locations)
+    return Array.from({ length: maxSprint + 1 }, (_, i) => i + 1);
+}
+export async function releaseCommand(args) {
+    const flags = parseArgs(args);
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    const registry = createRegistry(config, cwd);
+    // Release by ID
+    if (flags.id) {
+        const released = await registry.release(flags.id);
+        if (released) {
+            console.log(`\nClaim ${flags.id} released.\n`);
+        }
+        else {
+            console.error(`\nClaim ${flags.id} not found.\n`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Release by target + player lookup
+    if (flags.target) {
+        const player = flags.player || process.env.USER || 'unknown';
+        const sprints = resolveSprintRange(flags, cwd);
+        for (const sprint of sprints) {
+            const claims = await registry.list(sprint);
+            const match = claims.find(c => c.target === flags.target && c.player === player);
+            if (match) {
+                const released = await registry.release(match.id);
+                if (released) {
+                    console.log(`\nClaim ${match.id} (${match.target} by ${match.player}, sprint ${match.sprint_number}) released.\n`);
+                    return;
+                }
+            }
+        }
+        console.error(`\nNo claim found for target "${flags.target}" by player "${player}".\n`);
+        process.exit(1);
+        return;
+    }
+    console.error('Error: --id or --target is required');
+    process.exit(1);
+}

package/dist/commands/status.js

@@ -0,0 +1,64 @@
+import { checkConflicts } from '@slope-dev/core';
+import { loadConfig } from '../config.js';
+import { loadScorecards } from '../loader.js';
+import { createRegistry } from '../registries/index.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 resolveSprint(flags, cwd) {
+    if (flags.sprint)
+        return parseInt(flags.sprint, 10);
+    const config = loadConfig(cwd);
+    if (config.currentSprint)
+        return config.currentSprint;
+    const scorecards = loadScorecards(config, cwd);
+    if (scorecards.length === 0)
+        return 1;
+    const maxSprint = Math.max(...scorecards.map(s => s.sprint_number));
+    return maxSprint + 1;
+}
+export async function statusCommand(args) {
+    const flags = parseArgs(args);
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    const registry = createRegistry(config, cwd);
+    const sprintNumber = resolveSprint(flags, cwd);
+    const claims = await registry.list(sprintNumber);
+    console.log(`\nSprint ${sprintNumber} — Course Status`);
+    console.log('═'.repeat(40));
+    if (claims.length === 0) {
+        console.log('\n  No claims registered.\n');
+        return;
+    }
+    // Group by player
+    const byPlayer = new Map();
+    for (const claim of claims) {
+        const list = byPlayer.get(claim.player) || [];
+        list.push(claim);
+        byPlayer.set(claim.player, list);
+    }
+    for (const [player, playerClaims] of byPlayer) {
+        console.log(`\n  ${player}:`);
+        for (const c of playerClaims) {
+            const scopeTag = c.scope === 'area' ? '[area]' : '[ticket]';
+            const notes = c.notes ? ` — ${c.notes}` : '';
+            console.log(`    ${scopeTag} ${c.target}${notes}  (${c.id})`);
+        }
+    }
+    // Check conflicts
+    const conflicts = checkConflicts(claims);
+    if (conflicts.length > 0) {
+        console.log(`\n  Conflicts (${conflicts.length}):`);
+        for (const c of conflicts) {
+            const icon = c.severity === 'overlap' ? '!!' : '~';
+            console.log(`    [${icon}] ${c.reason} (${c.severity})`);
+        }
+    }
+    console.log('');
+}

package/dist/config.js

@@ -6,6 +6,8 @@ const DEFAULT_CONFIG = {
     minSprint: 1,
     commonIssuesPath: '.slope/common-issues.json',
     sessionsPath: '.slope/sessions.json',
+    registry: 'file',
+    claimsPath: '.slope/claims.json',
 };
 const CONFIG_DIR = '.slope';
 const CONFIG_FILE = 'config.json';

package/dist/index.js

@@ -7,9 +7,12 @@
  *   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 briefing [--sprint=N] [options]    Pre-round briefing
  *   slope plan --complexity=<level>         Pre-shot advisor
  *   slope classify --scope=... ...          Classify a shot
+ *   slope claim --target=<t> [--force]       Claim a ticket or area
+ *   slope release --id=<id>                 Release a claim
+ *   slope status [--sprint=N]               Show sprint course status
  */
 import { initCommand } from './commands/init.js';
 import { cardCommand } from './commands/card.js';
@@ -18,6 +21,9 @@ import { reviewCommand } from './commands/review.js';
 import { briefingCommand } from './commands/briefing.js';
 import { planCommand } from './commands/plan.js';
 import { classifyCommand } from './commands/classify.js';
+import { claimCommand } from './commands/claim.js';
+import { releaseCommand } from './commands/release.js';
+import { statusCommand } from './commands/status.js';
 const subcommand = process.argv[2];
 switch (subcommand) {
     case 'init':
@@ -37,7 +43,10 @@ switch (subcommand) {
         break;
     }
     case 'briefing':
-        briefingCommand(process.argv.slice(3));
+        briefingCommand(process.argv.slice(3)).catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
         break;
     case 'plan':
         planCommand(process.argv.slice(3));
@@ -45,6 +54,24 @@ switch (subcommand) {
     case 'classify':
         classifyCommand(process.argv.slice(3));
         break;
+    case 'claim':
+        claimCommand(process.argv.slice(3)).catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
+        break;
+    case 'release':
+        releaseCommand(process.argv.slice(3)).catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
+        break;
+    case 'status':
+        statusCommand(process.argv.slice(3)).catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
+        break;
     default:
         console.log(`
 SLOPE CLI — Sprint Lifecycle & Operational Performance Engine
@@ -54,9 +81,13 @@ Usage:
   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 briefing [--sprint=N] [options]      Pre-round briefing
   slope plan --complexity=<level>           Pre-shot advisor (club + training + hazards)
   slope classify --scope=... ...            Classify a shot from execution trace
+  slope claim --target=<t> [--force]        Claim a ticket or area for the sprint
+  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
 
 Examples:
   slope init                                Create .slope/ with config + example scorecard
@@ -72,6 +103,12 @@ Examples:
   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
+  slope briefing --sprint=2                 Briefing for sprint 2
+  slope claim --target=S2-1 --sprint=2      Claim ticket S2-1 for sprint 2
+  slope claim --target=packages/cli --scope=area  Claim an area
+  slope claim --target=S2-1 --force         Claim even if overlap conflict exists
+  slope status --sprint=2                   Show all claims for sprint 2
+  slope release --target=S2-1               Release your claim on S2-1
 `);
         process.exit(subcommand ? 1 : 0);
 }

package/dist/registries/api-registry.js

@@ -0,0 +1,40 @@
+export class ApiRegistry {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+    }
+    async claim(input) {
+        const res = await fetch(`${this.baseUrl}/claims`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(input),
+        });
+        if (!res.ok)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        return res.json();
+    }
+    async release(id) {
+        const res = await fetch(`${this.baseUrl}/claims/${encodeURIComponent(id)}`, {
+            method: 'DELETE',
+        });
+        if (res.status === 404)
+            return false;
+        if (!res.ok)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        return true;
+    }
+    async list(sprintNumber) {
+        const res = await fetch(`${this.baseUrl}/claims?sprint=${sprintNumber}`);
+        if (!res.ok)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        return res.json();
+    }
+    async get(id) {
+        const res = await fetch(`${this.baseUrl}/claims/${encodeURIComponent(id)}`);
+        if (res.status === 404)
+            return undefined;
+        if (!res.ok)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        return res.json();
+    }
+}

package/dist/registries/file-registry.js

@@ -0,0 +1,53 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class FileRegistry {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async claim(input) {
+        const claims = this.readClaims();
+        const claim = {
+            ...input,
+            id: `claim-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            claimed_at: new Date().toISOString(),
+        };
+        claims.push(claim);
+        this.writeClaims(claims);
+        return claim;
+    }
+    async release(id) {
+        const claims = this.readClaims();
+        const idx = claims.findIndex(c => c.id === id);
+        if (idx === -1)
+            return false;
+        claims.splice(idx, 1);
+        this.writeClaims(claims);
+        return true;
+    }
+    async list(sprintNumber) {
+        return this.readClaims().filter(c => c.sprint_number === sprintNumber);
+    }
+    async get(id) {
+        return this.readClaims().find(c => c.id === id);
+    }
+    readClaims() {
+        if (!existsSync(this.filePath))
+            return [];
+        try {
+            const data = JSON.parse(readFileSync(this.filePath, 'utf8'));
+            return Array.isArray(data.claims) ? data.claims : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    writeClaims(claims) {
+        const dir = dirname(this.filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const data = { claims };
+        writeFileSync(this.filePath, JSON.stringify(data, null, 2) + '\n');
+    }
+}

package/dist/registries/index.js

@@ -0,0 +1,18 @@
+import { join } from 'node:path';
+import { FileRegistry } from './file-registry.js';
+import { ApiRegistry } from './api-registry.js';
+export function createRegistry(config, cwd = process.cwd()) {
+    switch (config.registry) {
+        case 'api': {
+            if (!config.registryApiUrl) {
+                throw new Error('registryApiUrl is required when registry is set to "api"');
+            }
+            return new ApiRegistry(config.registryApiUrl);
+        }
+        case 'file':
+        default:
+            return new FileRegistry(join(cwd, config.claimsPath));
+    }
+}
+export { FileRegistry } from './file-registry.js';
+export { ApiRegistry } from './api-registry.js';

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@slope-dev/cli",
-  "version": "0.1.0",
+  "version": "0.2.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.1.0"
+    "@slope-dev/core": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
   },
   "files": [
     "dist"
@@ -34,8 +40,5 @@
   ],
   "engines": {
     "node": ">=18"
-  },
-  "scripts": {
-    "build": "tsc"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-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.