codesprint-mcp-server 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 CodeSprint Contributors
+
+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.
+
+Third-party notice: the interface icons in media/icons (except codesprint.svg)
+are from Lucide (https://lucide.dev), licensed under the ISC License.

package/README.md

@@ -1,3 +1,31 @@
-# Temporary Holding Version
+# codesprint-mcp-server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The engine behind the [CodeSprint extension for Zed](https://github.com/harshitsingh205/codesprint-zed): a zero-dependency [Model Context Protocol](https://modelcontextprotocol.io) server over stdio that provides a Pomodoro timer, daily goal, streaks and statistics.
+
+It works with any MCP client:
+
+```
+npx codesprint-mcp-server
+```
+
+| Tool | Purpose |
+| --- | --- |
+| `codesprint_status` | Timer state, time left, daily goal progress (read-only) |
+| `codesprint_start` / `pause` / `resume` / `reset` | Control the timer |
+| `codesprint_switch_mode` | `focus`, `shortBreak` or `longBreak` |
+| `codesprint_stats` | Today, week, streaks, 7-day chart (read-only) |
+| `codesprint_clear_data` | Delete all data; requires `confirm: true` |
+
+Prompts: `status`, `stats`.
+
+## Configuration
+
+Settings are JSON in the `CODESPRINT_SETTINGS` environment variable (the Zed extension fills this from `settings.json`). Invalid or missing values fall back to defaults. `CODESPRINT_DATA_DIR` overrides where `data.json` is stored.
+
+## Development
+
+```
+npm install
+npm test        # compile + 58 unit tests
+npm run build   # emits dist/
+```

package/dist/app.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_VERSION = void 0;
+exports.parseSettings = parseSettings;
+exports.createServer = createServer;
+const format_1 = require("./core/format");
+const settings_1 = require("./core/settings");
+const stats_1 = require("./core/stats");
+const time_1 = require("./core/time");
+const types_1 = require("./core/types");
+const types_2 = require("./core/types");
+const protocol_1 = require("./mcp/protocol");
+exports.SERVER_VERSION = '1.0.0';
+function parseSettings(raw) {
+    if (!raw) {
+        return { ...settings_1.DEFAULT_SETTINGS };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return (0, settings_1.normalizeSettings)(typeof parsed === 'object' && parsed !== null ? parsed : {});
+    }
+    catch {
+        return { ...settings_1.DEFAULT_SETTINGS };
+    }
+}
+function createServer(service, getSettings, clock = types_2.SYSTEM_CLOCK, write) {
+    const server = new protocol_1.McpServer({
+        name: 'codesprint',
+        title: 'CodeSprint',
+        version: exports.SERVER_VERSION,
+        instructions: 'CodeSprint is a Pomodoro focus timer with daily goals, streaks and statistics. ' +
+            'Use the codesprint_* tools when the user wants to start, pause, resume or reset a focus session, ' +
+            'switch to a break, or see their progress. Only completed sessions are counted.',
+    }, write);
+    const status = async (prefix) => {
+        const { timer, completionText } = await service.snapshot();
+        const body = (0, format_1.formatStatus)(timer, getSettings(), service.history(), clock.now());
+        return [prefix, completionText, body].filter(Boolean).join('\n\n');
+    };
+    const act = (label, noop, run) => async () => {
+        const result = await run();
+        return status(result.changed ? label : noop);
+    };
+    const noArgs = { type: 'object', properties: {}, additionalProperties: false };
+    server.addTool({
+        name: 'codesprint_status',
+        title: 'Timer status',
+        description: 'Show the current timer state, time remaining and progress toward the daily goal.',
+        inputSchema: noArgs,
+        annotations: { readOnlyHint: true, openWorldHint: false },
+        handler: () => status(),
+    });
+    server.addTool({
+        name: 'codesprint_start',
+        title: 'Start timer',
+        description: 'Start a session of the current type (focus by default), or resume it if it is paused.',
+        inputSchema: noArgs,
+        annotations: { idempotentHint: true, openWorldHint: false },
+        handler: act('Started.', 'The timer is already running.', () => service.start()),
+    });
+    server.addTool({
+        name: 'codesprint_pause',
+        title: 'Pause timer',
+        description: 'Pause the running session. Remaining time is kept.',
+        inputSchema: noArgs,
+        annotations: { idempotentHint: true, openWorldHint: false },
+        handler: act('Paused.', 'Nothing to pause: the timer is not running.', () => service.pause()),
+    });
+    server.addTool({
+        name: 'codesprint_resume',
+        title: 'Resume timer',
+        description: 'Resume a paused session.',
+        inputSchema: noArgs,
+        annotations: { idempotentHint: true, openWorldHint: false },
+        handler: act('Resumed.', 'Nothing to resume: the timer is not paused.', () => service.resume()),
+    });
+    server.addTool({
+        name: 'codesprint_reset',
+        title: 'Reset timer',
+        description: 'Discard the session in progress and return to idle. Unfinished sessions are never counted.',
+        inputSchema: noArgs,
+        annotations: { destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        handler: act('Session discarded.', 'Nothing to reset: the timer is idle.', () => service.reset()),
+    });
+    server.addTool({
+        name: 'codesprint_switch_mode',
+        title: 'Switch session type',
+        description: 'Switch between focus, shortBreak and longBreak. A session in progress is discarded, so confirm with the user first if one is running.',
+        inputSchema: {
+            type: 'object',
+            properties: { mode: { type: 'string', enum: [...types_1.SESSION_MODES], description: 'The session type to switch to.' } },
+            required: ['mode'],
+            additionalProperties: false,
+        },
+        annotations: { destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        handler: async (args) => {
+            const mode = args.mode;
+            if (!types_1.SESSION_MODES.includes(mode)) {
+                throw new Error(`mode must be one of: ${types_1.SESSION_MODES.join(', ')}.`);
+            }
+            const result = await service.setMode(mode);
+            return status(result.changed ? `Switched to ${format_1.MODE_LABELS[mode]}.` : `Already on ${format_1.MODE_LABELS[mode]}.`);
+        },
+    });
+    const statsText = async () => {
+        const goalMinutes = getSettings().dailyGoalMinutes;
+        await service.snapshot();
+        return (0, format_1.formatStats)((0, stats_1.computeStats)(service.history(), clock.now(), goalMinutes * time_1.MINUTE_MS), goalMinutes);
+    };
+    server.addTool({
+        name: 'codesprint_stats',
+        title: 'Productivity statistics',
+        description: 'Show today, weekly totals, completed sessions, current and longest streak and a 7-day overview.',
+        inputSchema: noArgs,
+        annotations: { readOnlyHint: true, openWorldHint: false },
+        handler: statsText,
+    });
+    server.addTool({
+        name: 'codesprint_clear_data',
+        title: 'Clear stored data',
+        description: 'Permanently delete all stored sessions, streaks and timer state. Irreversible: only call after the user has explicitly confirmed.',
+        inputSchema: {
+            type: 'object',
+            properties: { confirm: { type: 'boolean', description: 'Must be true to proceed.' } },
+            required: ['confirm'],
+            additionalProperties: false,
+        },
+        annotations: { destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        handler: async (args) => {
+            if (args.confirm !== true) {
+                throw new Error('Refusing to delete data without confirm: true.');
+            }
+            await service.clearAllData();
+            return 'All CodeSprint data has been cleared.';
+        },
+    });
+    server.addPrompt({
+        name: 'status',
+        title: 'Timer status',
+        description: 'Insert the current CodeSprint timer status into the conversation.',
+        handler: () => status(),
+    });
+    server.addPrompt({
+        name: 'stats',
+        title: 'Productivity statistics',
+        description: 'Insert your CodeSprint streaks and weekly statistics into the conversation.',
+        handler: statsText,
+    });
+    return server;
+}

package/dist/core/format.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODE_LABELS = void 0;
+exports.progressBar = progressBar;
+exports.formatStatus = formatStatus;
+exports.formatStats = formatStats;
+const messages_1 = require("./messages");
+const stats_1 = require("./stats");
+const time_1 = require("./time");
+exports.MODE_LABELS = {
+    focus: 'Focus',
+    shortBreak: 'Short break',
+    longBreak: 'Long break',
+};
+const STATUS_LABELS = { idle: 'Ready', running: 'Running', paused: 'Paused' };
+function progressBar(percent, width = 20) {
+    const filled = Math.round((Math.min(100, Math.max(0, percent)) / 100) * width);
+    return `[${'#'.repeat(filled)}${'-'.repeat(width - filled)}] ${Math.round(percent)}%`;
+}
+function formatStatus(timer, settings, history, now) {
+    const stats = (0, stats_1.computeStats)(history, now, settings.dailyGoalMinutes * time_1.MINUTE_MS);
+    const lines = [
+        `Timer: ${exports.MODE_LABELS[timer.mode]} - ${STATUS_LABELS[timer.status]}`,
+        `Time ${timer.status === 'idle' ? 'planned' : 'remaining'}: ${(0, time_1.formatClock)(timer.remainingMs)}`,
+        `Cycle: ${timer.cycleDone} of ${timer.cycleLength} focus sessions before a long break`,
+        `Today: ${(0, time_1.formatDuration)(stats.todayFocusMs)} of ${(0, time_1.formatDuration)(settings.dailyGoalMinutes * time_1.MINUTE_MS)}  ${progressBar(stats.goalPercent)}`,
+    ];
+    if (timer.endsAt !== null) {
+        lines.splice(2, 0, `Ends at: ${new Date(timer.endsAt).toLocaleTimeString()}`);
+    }
+    const key = (0, time_1.dayKey)(now);
+    lines.push('', timer.mode !== 'focus' && timer.status === 'running' ? (0, messages_1.breakMessage)(key) : (0, messages_1.dailyMessage)(key));
+    return lines.join('\n');
+}
+function formatStats(stats, goalMinutes) {
+    const goalMs = goalMinutes * time_1.MINUTE_MS;
+    const rows = stats.week.map((d) => {
+        const bar = '#'.repeat(Math.round((d.focusMs / stats.weekMaxMs) * 20)).padEnd(20, '.');
+        const label = `${d.label} ${d.key.slice(5)}${d.isToday ? '*' : ' '}`;
+        return `  ${label} ${bar} ${(0, time_1.formatDuration)(d.focusMs)}`;
+    });
+    return [
+        `Today:             ${(0, time_1.formatDuration)(stats.todayFocusMs)} of ${(0, time_1.formatDuration)(goalMs)}  ${progressBar(stats.goalPercent)}`,
+        `Daily goal:        ${stats.goalMet ? 'reached' : 'not yet reached'}`,
+        `This week:         ${(0, time_1.formatDuration)(stats.weekFocusMs)} (${stats.weekActiveDays} active days)`,
+        `Completed sessions: ${stats.totalSessions}`,
+        `Current streak:    ${stats.currentStreak} ${stats.currentStreak === 1 ? 'day' : 'days'}`,
+        `Longest streak:    ${stats.longestStreak} ${stats.longestStreak === 1 ? 'day' : 'days'}`,
+        `Active days:       ${stats.activeDays}`,
+        '',
+        'Last 7 days (* = today):',
+        ...rows,
+    ].join('\n');
+}

package/dist/core/history.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DAYS = exports.MAX_RECENT_SESSIONS = void 0;
+exports.emptyHistory = emptyHistory;
+exports.sanitizeHistory = sanitizeHistory;
+exports.addSession = addSession;
+const types_1 = require("./types");
+const time_1 = require("./time");
+exports.MAX_RECENT_SESSIONS = 200;
+exports.MAX_DAYS = 1100;
+const MAX_REASONABLE_MS = 24 * 60 * 60 * 1000;
+function emptyHistory() {
+    return { version: 1, totalSessions: 0, days: {}, recent: [] };
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isNonNegInt = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+function sanitizeSession(raw) {
+    if (!isRecord(raw)) {
+        return undefined;
+    }
+    const { id, mode, plannedMs, startedAt, endedAt } = raw;
+    if (typeof id !== 'string' ||
+        id.length === 0 ||
+        id.length > 64 ||
+        !types_1.SESSION_MODES.includes(mode) ||
+        typeof plannedMs !== 'number' ||
+        !Number.isFinite(plannedMs) ||
+        plannedMs <= 0 ||
+        plannedMs > MAX_REASONABLE_MS ||
+        typeof startedAt !== 'number' ||
+        !Number.isFinite(startedAt) ||
+        typeof endedAt !== 'number' ||
+        !Number.isFinite(endedAt)) {
+        return undefined;
+    }
+    return { id, mode: mode, plannedMs, startedAt, endedAt };
+}
+function sanitizeHistory(raw) {
+    const history = emptyHistory();
+    if (!isRecord(raw)) {
+        return history;
+    }
+    if (isRecord(raw.days)) {
+        for (const [key, value] of Object.entries(raw.days)) {
+            if (!(0, time_1.isDayKey)(key) || !isRecord(value)) {
+                continue;
+            }
+            const { focusMs, sessions } = value;
+            if (typeof focusMs === 'number' &&
+                Number.isFinite(focusMs) &&
+                focusMs >= 0 &&
+                isNonNegInt(sessions)) {
+                history.days[key] = { focusMs, sessions };
+            }
+        }
+    }
+    if (Array.isArray(raw.recent)) {
+        for (const item of raw.recent) {
+            const session = sanitizeSession(item);
+            if (session) {
+                history.recent.push(session);
+            }
+        }
+        history.recent = history.recent.slice(-exports.MAX_RECENT_SESSIONS);
+    }
+    const sumDays = Object.values(history.days).reduce((acc, d) => acc + d.sessions, 0);
+    history.totalSessions = isNonNegInt(raw.totalSessions) ? Math.max(raw.totalSessions, sumDays) : sumDays;
+    return history;
+}
+function addSession(history, session) {
+    if (history.recent.some((s) => s.id === session.id)) {
+        return false;
+    }
+    history.recent.push(session);
+    if (history.recent.length > exports.MAX_RECENT_SESSIONS) {
+        history.recent.splice(0, history.recent.length - exports.MAX_RECENT_SESSIONS);
+    }
+    if (session.mode === 'focus') {
+        const key = (0, time_1.dayKey)(session.endedAt);
+        const day = history.days[key] ?? { focusMs: 0, sessions: 0 };
+        day.focusMs += session.plannedMs;
+        day.sessions += 1;
+        history.days[key] = day;
+        history.totalSessions += 1;
+        const keys = Object.keys(history.days);
+        if (keys.length > exports.MAX_DAYS) {
+            keys.sort();
+            for (const old of keys.slice(0, keys.length - exports.MAX_DAYS)) {
+                delete history.days[old];
+            }
+        }
+    }
+    return true;
+}

package/dist/core/messages.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BREAK_MESSAGES = exports.GOAL_REACHED_MESSAGE = exports.COMPLETION_MESSAGES = exports.DAILY_MESSAGES = void 0;
+exports.dailyMessage = dailyMessage;
+exports.breakMessage = breakMessage;
+exports.completionMessage = completionMessage;
+exports.DAILY_MESSAGES = [
+    'Every expert was once a beginner.',
+    'Consistency creates progress.',
+    'Focus on improvement, not perfection.',
+    'Every problem solved makes you better.',
+    'Small sessions add up to real skill.',
+    'Show up today and the results will follow.',
+    'Clear code starts with a clear mind.',
+    'Progress is built one focused session at a time.',
+    'Debugging is how you learn how things really work.',
+    'Start with the next small step.',
+    'Steady practice beats occasional intensity.',
+    'You do not need to be perfect to move forward.',
+];
+exports.COMPLETION_MESSAGES = [
+    'Session complete. Steady work like this builds real skill.',
+    'Well done. Consistency creates progress.',
+    'Another focused session logged. Keep the momentum.',
+    'Good work. Every problem solved makes you better.',
+    'Focus session finished. Small wins compound.',
+    'Nice work. Rest, then continue.',
+];
+exports.GOAL_REACHED_MESSAGE = 'Daily goal reached. Excellent consistency today.';
+exports.BREAK_MESSAGES = [
+    'Look away from the screen and rest your eyes.',
+    'Stand up, stretch and drink some water.',
+    'Rest is part of the work.',
+];
+function hash(text) {
+    let h = 0;
+    for (let i = 0; i < text.length; i++) {
+        h = (h * 31 + text.charCodeAt(i)) >>> 0;
+    }
+    return h;
+}
+function dailyMessage(dayKeyValue) {
+    return exports.DAILY_MESSAGES[hash(dayKeyValue) % exports.DAILY_MESSAGES.length];
+}
+function breakMessage(dayKeyValue) {
+    return exports.BREAK_MESSAGES[hash(dayKeyValue) % exports.BREAK_MESSAGES.length];
+}
+function completionMessage(sessionsToday) {
+    const index = Math.max(0, sessionsToday - 1) % exports.COMPLETION_MESSAGES.length;
+    return exports.COMPLETION_MESSAGES[index];
+}

package/dist/core/notifier.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullNotifier = exports.DesktopNotifier = void 0;
+const node_child_process_1 = require("node:child_process");
+class DesktopNotifier {
+    platform;
+    constructor(platform = process.platform) {
+        this.platform = platform;
+    }
+    notify(title, body) {
+        try {
+            const [command, args, env] = this.buildCommand(title, body);
+            const child = (0, node_child_process_1.spawn)(command, args, {
+                stdio: 'ignore',
+                windowsHide: true,
+                detached: false,
+                env: { ...process.env, ...env },
+            });
+            child.on('error', () => undefined);
+            child.unref();
+        }
+        catch {
+        }
+    }
+    buildCommand(title, body) {
+        switch (this.platform) {
+            case 'darwin': {
+                const esc = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                return ['osascript', ['-e', `display notification "${esc(body)}" with title "${esc(title)}"`], {}];
+            }
+            case 'win32': {
+                const script = 'Add-Type -AssemblyName System.Windows.Forms;' +
+                    '$n = New-Object System.Windows.Forms.NotifyIcon;' +
+                    '$n.Icon = [System.Drawing.SystemIcons]::Information;' +
+                    '$n.Visible = $true;' +
+                    '$n.ShowBalloonTip(8000, $env:CS_TITLE, $env:CS_BODY, [System.Windows.Forms.ToolTipIcon]::None);' +
+                    'Start-Sleep -Seconds 9; $n.Dispose()';
+                return ['powershell', ['-NoProfile', '-NonInteractive', '-Command', script], { CS_TITLE: title, CS_BODY: body }];
+            }
+            default:
+                return ['notify-send', ['--app-name=CodeSprint', '--', title, body], {}];
+        }
+    }
+}
+exports.DesktopNotifier = DesktopNotifier;
+class NullNotifier {
+    notify() {
+    }
+}
+exports.NullNotifier = NullNotifier;

package/dist/core/settings.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTING_KEYS = exports.SETTING_SPECS = exports.DEFAULT_SETTINGS = void 0;
+exports.isSettingKey = isSettingKey;
+exports.validateSettingValue = validateSettingValue;
+exports.normalizeSettings = normalizeSettings;
+exports.toEngineConfig = toEngineConfig;
+const time_1 = require("./time");
+exports.DEFAULT_SETTINGS = {
+    focusMinutes: 25,
+    shortBreakMinutes: 5,
+    longBreakMinutes: 15,
+    dailyGoalMinutes: 120,
+    notifications: true,
+    autoBreakSuggestions: true,
+    sessionsBeforeLongBreak: 4,
+};
+exports.SETTING_SPECS = {
+    focusMinutes: { kind: 'int', min: 1, max: 180 },
+    shortBreakMinutes: { kind: 'int', min: 1, max: 60 },
+    longBreakMinutes: { kind: 'int', min: 1, max: 120 },
+    dailyGoalMinutes: { kind: 'int', min: 5, max: 1440 },
+    notifications: { kind: 'boolean' },
+    autoBreakSuggestions: { kind: 'boolean' },
+    sessionsBeforeLongBreak: { kind: 'int', min: 2, max: 10 },
+};
+exports.SETTING_KEYS = Object.keys(exports.SETTING_SPECS);
+function isSettingKey(key) {
+    return typeof key === 'string' && Object.prototype.hasOwnProperty.call(exports.SETTING_SPECS, key);
+}
+function validateSettingValue(key, value) {
+    if (!isSettingKey(key)) {
+        return undefined;
+    }
+    const spec = exports.SETTING_SPECS[key];
+    switch (spec.kind) {
+        case 'enum':
+            return typeof value === 'string' && spec.values.includes(value) ? value : undefined;
+        case 'int':
+            return typeof value === 'number' && Number.isInteger(value) && value >= spec.min && value <= spec.max
+                ? value
+                : undefined;
+        case 'boolean':
+            return typeof value === 'boolean' ? value : undefined;
+    }
+}
+function normalizeSettings(raw) {
+    const out = { ...exports.DEFAULT_SETTINGS };
+    for (const key of exports.SETTING_KEYS) {
+        const spec = exports.SETTING_SPECS[key];
+        const value = raw[key];
+        if (spec.kind === 'int' && typeof value === 'number' && Number.isFinite(value)) {
+            out[key] = Math.min(spec.max, Math.max(spec.min, Math.round(value)));
+        }
+        else if (spec.kind === 'enum' && typeof value === 'string' && spec.values.includes(value)) {
+            out[key] = value;
+        }
+        else if (spec.kind === 'boolean' && typeof value === 'boolean') {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function toEngineConfig(s) {
+    return {
+        durations: {
+            focusMs: s.focusMinutes * time_1.MINUTE_MS,
+            shortBreakMs: s.shortBreakMinutes * time_1.MINUTE_MS,
+            longBreakMs: s.longBreakMinutes * time_1.MINUTE_MS,
+        },
+        autoBreakSuggestions: s.autoBreakSuggestions,
+        sessionsBeforeLongBreak: s.sessionsBeforeLongBreak,
+    };
+}

package/dist/core/stats.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStreaks = computeStreaks;
+exports.computeStats = computeStats;
+const time_1 = require("./time");
+const SHORT = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
+const FULL = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const isActive = (d) => !!d && d.sessions > 0;
+function runEndingAt(days, endKey) {
+    let count = 0;
+    let key = endKey;
+    while (isActive(days[key])) {
+        count += 1;
+        key = (0, time_1.shiftDayKey)(key, -1);
+    }
+    return count;
+}
+function computeStreaks(days, todayKey) {
+    const activeKeys = Object.keys(days)
+        .filter((k) => isActive(days[k]))
+        .sort();
+    let longest = 0;
+    let run = 0;
+    let previous;
+    for (const key of activeKeys) {
+        run = previous !== undefined && (0, time_1.shiftDayKey)(previous, 1) === key ? run + 1 : 1;
+        longest = Math.max(longest, run);
+        previous = key;
+    }
+    const current = isActive(days[todayKey])
+        ? runEndingAt(days, todayKey)
+        : runEndingAt(days, (0, time_1.shiftDayKey)(todayKey, -1));
+    return { current, longest, activeDays: activeKeys.length };
+}
+function computeStats(history, now, goalMs) {
+    const todayKey = (0, time_1.dayKey)(now);
+    const days = history.days;
+    const today = days[todayKey]?.focusMs ?? 0;
+    const week = [];
+    for (let i = 6; i >= 0; i--) {
+        const key = (0, time_1.shiftDayKey)(todayKey, -i);
+        const record = days[key];
+        const dow = (0, time_1.parseDayKey)(key).getDay();
+        week.push({
+            key,
+            label: SHORT[dow],
+            fullLabel: FULL[dow],
+            focusMs: record?.focusMs ?? 0,
+            sessions: record?.sessions ?? 0,
+            active: isActive(record),
+            isToday: i === 0,
+        });
+    }
+    const streaks = computeStreaks(days, todayKey);
+    const goalPercent = goalMs > 0 ? Math.min(100, Math.round((today / goalMs) * 100)) : 0;
+    return {
+        todayFocusMs: today,
+        totalSessions: history.totalSessions,
+        weekFocusMs: week.reduce((sum, d) => sum + d.focusMs, 0),
+        goalPercent,
+        goalMet: goalMs > 0 && today >= goalMs,
+        currentStreak: streaks.current,
+        longestStreak: streaks.longest,
+        activeDays: streaks.activeDays,
+        week,
+        weekActiveDays: week.filter((d) => d.active).length,
+        weekMaxMs: Math.max(goalMs, ...week.map((d) => d.focusMs), 1),
+    };
+}

package/dist/core/storage.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = exports.Store = exports.STORAGE_KEYS = void 0;
+exports.defaultDataDir = defaultDataDir;
+const fs = require("node:fs");
+const path = require("node:path");
+const timerState_1 = require("./timerState");
+const history_1 = require("./history");
+exports.STORAGE_KEYS = {
+    timer: 'codesprint.timer.v1',
+    history: 'codesprint.history.v1',
+};
+class Store {
+    kv;
+    constructor(kv) {
+        this.kv = kv;
+    }
+    read(key) {
+        try {
+            return this.kv.get(key);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    loadTimerState(config, now) {
+        return (0, timerState_1.sanitizeTimerState)(this.read(exports.STORAGE_KEYS.timer), now, config);
+    }
+    saveTimerState(state) {
+        return this.kv.update(exports.STORAGE_KEYS.timer, state);
+    }
+    loadHistory() {
+        return (0, history_1.sanitizeHistory)(this.read(exports.STORAGE_KEYS.history));
+    }
+    async recordSession(session) {
+        const history = this.loadHistory();
+        if (!(0, history_1.addSession)(history, session)) {
+            return false;
+        }
+        await this.kv.update(exports.STORAGE_KEYS.history, history);
+        return true;
+    }
+    async clearAll() {
+        await this.kv.update(exports.STORAGE_KEYS.timer, undefined);
+        await this.kv.update(exports.STORAGE_KEYS.history, (0, history_1.emptyHistory)());
+    }
+}
+exports.Store = Store;
+class FileStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    readAll() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+            return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+                ? parsed
+                : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    get(key) {
+        return this.readAll()[key];
+    }
+    update(key, value) {
+        const data = this.readAll();
+        if (value === undefined) {
+            delete data[key];
+        }
+        else {
+            data[key] = value;
+        }
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        const tmp = `${this.file}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(data), { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(tmp, this.file);
+        return Promise.resolve();
+    }
+}
+exports.FileStore = FileStore;
+function defaultDataDir(env = process.env, platform = process.platform) {
+    if (env.CODESPRINT_DATA_DIR) {
+        return env.CODESPRINT_DATA_DIR;
+    }
+    const home = env.HOME ?? env.USERPROFILE ?? '.';
+    if (platform === 'win32') {
+        return path.join(env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'CodeSprint');
+    }
+    if (platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'CodeSprint');
+    }
+    return path.join(env.XDG_DATA_HOME ?? path.join(home, '.local', 'share'), 'codesprint');
+}

package/dist/core/time.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINUTE_MS = void 0;
+exports.dayKey = dayKey;
+exports.parseDayKey = parseDayKey;
+exports.isDayKey = isDayKey;
+exports.shiftDayKey = shiftDayKey;
+exports.formatClock = formatClock;
+exports.formatDuration = formatDuration;
+exports.greetingForHour = greetingForHour;
+exports.MINUTE_MS = 60_000;
+const pad = (n) => String(n).padStart(2, '0');
+function dayKey(ts) {
+    const d = new Date(ts);
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function parseDayKey(key) {
+    const [y, m, d] = key.split('-').map(Number);
+    return new Date(y, m - 1, d, 12, 0, 0, 0);
+}
+function isDayKey(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        return false;
+    }
+    return dayKey(parseDayKey(value).getTime()) === value;
+}
+function shiftDayKey(key, deltaDays) {
+    const d = parseDayKey(key);
+    d.setDate(d.getDate() + deltaDays);
+    return dayKey(d.getTime());
+}
+function formatClock(ms) {
+    const total = Math.max(0, Math.ceil(ms / 1000));
+    return `${pad(Math.floor(total / 60))}:${pad(total % 60)}`;
+}
+function formatDuration(ms) {
+    const minutes = Math.max(0, Math.round(ms / exports.MINUTE_MS));
+    const h = Math.floor(minutes / 60);
+    const m = minutes % 60;
+    if (h > 0 && m > 0) {
+        return `${h}h ${m}m`;
+    }
+    return h > 0 ? `${h}h` : `${m}m`;
+}
+function greetingForHour(hour) {
+    if (hour < 12) {
+        return 'Good morning';
+    }
+    return hour < 18 ? 'Good afternoon' : 'Good evening';
+}

package/dist/core/timerEngine.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimerEngine = exports.MAX_DURATION_MS = exports.MIN_DURATION_MS = void 0;
+exports.durationFor = durationFor;
+exports.createIdleState = createIdleState;
+exports.MIN_DURATION_MS = 1_000;
+exports.MAX_DURATION_MS = 24 * 60 * 60 * 1000;
+function durationFor(mode, d) {
+    switch (mode) {
+        case 'focus':
+            return d.focusMs;
+        case 'shortBreak':
+            return d.shortBreakMs;
+        case 'longBreak':
+            return d.longBreakMs;
+    }
+}
+function createIdleState(mode, config, focusSinceLongBreak = 0) {
+    return {
+        mode,
+        status: 'idle',
+        durationMs: durationFor(mode, config.durations),
+        elapsedMs: 0,
+        segmentStartedAt: null,
+        sessionStartedAt: null,
+        focusSinceLongBreak,
+    };
+}
+class TimerEngine {
+    getConfig;
+    clock;
+    state;
+    constructor(getConfig, clock, initial) {
+        this.getConfig = getConfig;
+        this.clock = clock;
+        this.state = initial ? { ...initial } : createIdleState('focus', getConfig());
+    }
+    getState() {
+        return { ...this.state };
+    }
+    get status() {
+        return this.state.status;
+    }
+    get mode() {
+        return this.state.mode;
+    }
+    elapsedMs(now = this.clock.now()) {
+        const s = this.state;
+        if (s.status === 'idle') {
+            return 0;
+        }
+        if (s.status === 'running' && s.segmentStartedAt !== null) {
+            const segment = Math.max(0, now - s.segmentStartedAt);
+            return Math.min(s.durationMs, s.elapsedMs + segment);
+        }
+        return s.elapsedMs;
+    }
+    remainingMs(now = this.clock.now()) {
+        if (this.state.status === 'idle') {
+            return this.state.durationMs;
+        }
+        return Math.max(0, this.state.durationMs - this.elapsedMs(now));
+    }
+    snapshot(now = this.clock.now()) {
+        const s = this.state;
+        const cfg = this.getConfig();
+        const remainingMs = this.remainingMs(now);
+        return {
+            mode: s.mode,
+            status: s.status,
+            durationMs: s.durationMs,
+            remainingMs,
+            endsAt: s.status === 'running' ? now + remainingMs : null,
+            cycleDone: Math.min(s.focusSinceLongBreak, cfg.sessionsBeforeLongBreak),
+            cycleLength: cfg.sessionsBeforeLongBreak,
+        };
+    }
+    start() {
+        const s = this.state;
+        if (s.status === 'running') {
+            return false;
+        }
+        if (s.status === 'paused') {
+            return this.resume();
+        }
+        const now = this.clock.now();
+        this.state = {
+            ...s,
+            status: 'running',
+            durationMs: durationFor(s.mode, this.getConfig().durations),
+            elapsedMs: 0,
+            segmentStartedAt: now,
+            sessionStartedAt: now,
+        };
+        return true;
+    }
+    pause() {
+        const s = this.state;
+        if (s.status !== 'running') {
+            return false;
+        }
+        const now = this.clock.now();
+        if (this.remainingMs(now) <= 0) {
+            return false;
+        }
+        this.state = { ...s, status: 'paused', elapsedMs: this.elapsedMs(now), segmentStartedAt: null };
+        return true;
+    }
+    resume() {
+        const s = this.state;
+        if (s.status !== 'paused') {
+            return false;
+        }
+        this.state = { ...s, status: 'running', segmentStartedAt: this.clock.now() };
+        return true;
+    }
+    reset() {
+        const s = this.state;
+        if (s.status === 'idle') {
+            return false;
+        }
+        this.state = createIdleState(s.mode, this.getConfig(), s.focusSinceLongBreak);
+        return true;
+    }
+    setMode(mode) {
+        this.state = createIdleState(mode, this.getConfig(), this.state.focusSinceLongBreak);
+    }
+    restart() {
+        this.state = createIdleState('focus', this.getConfig(), 0);
+    }
+    syncDurations() {
+        const s = this.state;
+        if (s.status !== 'idle') {
+            return false;
+        }
+        const durationMs = durationFor(s.mode, this.getConfig().durations);
+        if (durationMs === s.durationMs) {
+            return false;
+        }
+        this.state = { ...s, durationMs };
+        return true;
+    }
+    checkCompletion() {
+        const s = this.state;
+        if (s.status !== 'running' || s.segmentStartedAt === null) {
+            return undefined;
+        }
+        if (this.remainingMs() > 0) {
+            return undefined;
+        }
+        const endedAt = s.segmentStartedAt + (s.durationMs - s.elapsedMs);
+        const startedAt = s.sessionStartedAt ?? s.segmentStartedAt;
+        const session = {
+            id: `${startedAt}-${s.mode}`,
+            mode: s.mode,
+            plannedMs: s.durationMs,
+            startedAt,
+            endedAt,
+        };
+        const cfg = this.getConfig();
+        let nextMode = 'focus';
+        let focusSinceLongBreak = s.focusSinceLongBreak;
+        if (s.mode === 'focus') {
+            focusSinceLongBreak += 1;
+            if (cfg.autoBreakSuggestions) {
+                nextMode = focusSinceLongBreak >= cfg.sessionsBeforeLongBreak ? 'longBreak' : 'shortBreak';
+            }
+        }
+        else if (s.mode === 'longBreak') {
+            focusSinceLongBreak = 0;
+        }
+        this.state = createIdleState(nextMode, cfg, focusSinceLongBreak);
+        return { session, nextMode };
+    }
+}
+exports.TimerEngine = TimerEngine;

package/dist/core/timerService.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimerService = void 0;
+const format_1 = require("./format");
+const messages_1 = require("./messages");
+const settings_1 = require("./settings");
+const timerEngine_1 = require("./timerEngine");
+const types_1 = require("./types");
+const time_1 = require("./time");
+class TimerService {
+    store;
+    getSettings;
+    notifier;
+    clock;
+    wake;
+    constructor(store, getSettings, notifier, clock = types_1.SYSTEM_CLOCK) {
+        this.store = store;
+        this.getSettings = getSettings;
+        this.notifier = notifier;
+        this.clock = clock;
+    }
+    engine() {
+        const getConfig = () => (0, settings_1.toEngineConfig)(this.getSettings());
+        return new timerEngine_1.TimerEngine(getConfig, this.clock, this.store.loadTimerState(getConfig(), this.clock.now()));
+    }
+    async finalize(engine) {
+        const completion = engine.checkCompletion();
+        if (!completion) {
+            return undefined;
+        }
+        await this.store.recordSession(completion.session);
+        await this.store.saveTimerState(engine.getState());
+        const text = this.completionTextFor(completion);
+        this.notifyCompletion(completion, text);
+        return text;
+    }
+    completionTextFor(completion) {
+        const { session } = completion;
+        if (session.mode !== 'focus') {
+            return undefined;
+        }
+        const today = this.store.loadHistory().days[(0, time_1.dayKey)(session.endedAt)];
+        const goalMs = this.getSettings().dailyGoalMinutes * time_1.MINUTE_MS;
+        const justReached = !!today && today.focusMs >= goalMs && today.focusMs - session.plannedMs < goalMs;
+        return justReached ? messages_1.GOAL_REACHED_MESSAGE : (0, messages_1.completionMessage)(today?.sessions ?? 1);
+    }
+    notifyCompletion(completion, text) {
+        if (!this.getSettings().notifications) {
+            return;
+        }
+        const { session, nextMode } = completion;
+        const minutes = Math.max(1, Math.round(session.plannedMs / time_1.MINUTE_MS));
+        if (session.mode === 'focus') {
+            const next = nextMode === 'focus' ? '' : ` Next: ${format_1.MODE_LABELS[nextMode]}.`;
+            this.notifier.notify('CodeSprint - focus session complete', `${minutes} min logged.${next} ${text ?? ''}`.trim());
+        }
+        else {
+            this.notifier.notify(`CodeSprint - ${format_1.MODE_LABELS[session.mode]} finished`, 'Ready for the next focus session?');
+        }
+    }
+    schedule(engine) {
+        if (this.wake) {
+            clearTimeout(this.wake);
+            this.wake = undefined;
+        }
+        if (engine.status !== 'running') {
+            return;
+        }
+        const delay = Math.min(engine.remainingMs() + 250, 2 ** 31 - 1);
+        this.wake = setTimeout(() => void this.tick(), delay);
+        this.wake.unref();
+    }
+    async tick() {
+        const engine = this.engine();
+        await this.finalize(engine);
+        this.schedule(engine);
+    }
+    async initialize() {
+        const engine = this.engine();
+        await this.finalize(engine);
+        this.schedule(engine);
+    }
+    async snapshot() {
+        const engine = this.engine();
+        const completionText = await this.finalize(engine);
+        this.schedule(engine);
+        return { timer: engine.snapshot(), completionText };
+    }
+    async run(action, reschedule = true) {
+        const engine = this.engine();
+        const completionText = await this.finalize(engine);
+        const changed = action(engine);
+        if (changed) {
+            await this.store.saveTimerState(engine.getState());
+        }
+        if (reschedule) {
+            this.schedule(engine);
+        }
+        return { changed, completionText };
+    }
+    start() {
+        return this.run((e) => e.start());
+    }
+    pause() {
+        return this.run((e) => e.pause());
+    }
+    resume() {
+        return this.run((e) => e.resume());
+    }
+    reset() {
+        return this.run((e) => e.reset());
+    }
+    setMode(mode) {
+        if (!types_1.SESSION_MODES.includes(mode)) {
+            return Promise.resolve({ changed: false });
+        }
+        return this.run((e) => {
+            if (e.mode === mode) {
+                return false;
+            }
+            e.setMode(mode);
+            return true;
+        });
+    }
+    async clearAllData() {
+        await this.store.clearAll();
+        if (this.wake) {
+            clearTimeout(this.wake);
+            this.wake = undefined;
+        }
+    }
+    history() {
+        return this.store.loadHistory();
+    }
+    dispose() {
+        if (this.wake) {
+            clearTimeout(this.wake);
+        }
+    }
+}
+exports.TimerService = TimerService;

package/dist/core/timerState.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeTimerState = sanitizeTimerState;
+const timerEngine_1 = require("./timerEngine");
+const types_1 = require("./types");
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isFiniteNumber = (v) => typeof v === 'number' && Number.isFinite(v);
+function sanitizeTimerState(raw, now, config) {
+    if (!isRecord(raw)) {
+        return undefined;
+    }
+    const { mode, status, durationMs, elapsedMs, segmentStartedAt, sessionStartedAt, focusSinceLongBreak } = raw;
+    if (!types_1.SESSION_MODES.includes(mode) || !types_1.TIMER_STATUSES.includes(status)) {
+        return undefined;
+    }
+    const safeMode = mode;
+    const safeStatus = status;
+    const cycle = typeof focusSinceLongBreak === 'number' && Number.isInteger(focusSinceLongBreak)
+        ? Math.min(Math.max(focusSinceLongBreak, 0), 1000)
+        : 0;
+    if (safeStatus === 'idle') {
+        return (0, timerEngine_1.createIdleState)(safeMode, config, cycle);
+    }
+    if (!isFiniteNumber(durationMs) || durationMs < timerEngine_1.MIN_DURATION_MS || durationMs > timerEngine_1.MAX_DURATION_MS) {
+        return undefined;
+    }
+    if (!isFiniteNumber(elapsedMs) || elapsedMs < 0 || elapsedMs > durationMs) {
+        return undefined;
+    }
+    let segment = null;
+    if (safeStatus === 'running') {
+        if (!isFiniteNumber(segmentStartedAt) || segmentStartedAt <= 0) {
+            return undefined;
+        }
+        segment = Math.min(segmentStartedAt, now);
+    }
+    const started = isFiniteNumber(sessionStartedAt) && sessionStartedAt > 0 ? Math.min(sessionStartedAt, now) : segment ?? now;
+    return {
+        mode: safeMode,
+        status: safeStatus,
+        durationMs,
+        elapsedMs,
+        segmentStartedAt: segment,
+        sessionStartedAt: started,
+        focusSinceLongBreak: cycle,
+    };
+}

package/dist/core/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_CLOCK = exports.TIMER_STATUSES = exports.SESSION_MODES = void 0;
+exports.SESSION_MODES = ['focus', 'shortBreak', 'longBreak'];
+exports.TIMER_STATUSES = ['idle', 'running', 'paused'];
+exports.SYSTEM_CLOCK = { now: () => Date.now() };

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("node:path");
+const app_1 = require("./app");
+const notifier_1 = require("./core/notifier");
+const storage_1 = require("./core/storage");
+const timerService_1 = require("./core/timerService");
+async function main() {
+    const settings = (0, app_1.parseSettings)(process.env.CODESPRINT_SETTINGS);
+    const store = new storage_1.Store(new storage_1.FileStore(path.join((0, storage_1.defaultDataDir)(), 'data.json')));
+    const service = new timerService_1.TimerService(store, () => settings, new notifier_1.DesktopNotifier());
+    await service.initialize();
+    const server = (0, app_1.createServer)(service, () => settings);
+    await server.listen();
+    service.dispose();
+}
+main().catch((e) => {
+    process.stderr.write(`[codesprint] fatal: ${e.stack ?? String(e)}\n`);
+    process.exit(1);
+});

package/dist/mcp/protocol.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = exports.SUPPORTED_PROTOCOL_VERSIONS = void 0;
+const readline = require("node:readline");
+exports.SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+const ERR = { parse: -32700, invalidRequest: -32600, notFound: -32601, invalidParams: -32602, internal: -32603 };
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+class McpServer {
+    info;
+    write;
+    tools = new Map();
+    prompts = new Map();
+    constructor(info, write = (line) => process.stdout.write(line + '\n')) {
+        this.info = info;
+        this.write = write;
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    addPrompt(prompt) {
+        this.prompts.set(prompt.name, prompt);
+    }
+    listen(input = process.stdin) {
+        const rl = readline.createInterface({ input, crlfDelay: Infinity });
+        rl.on('line', (line) => {
+            if (line.trim()) {
+                void this.handleLine(line);
+            }
+        });
+        return new Promise((resolve) => rl.on('close', resolve));
+    }
+    async handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.error(null, ERR.parse, 'Parse error');
+            return;
+        }
+        if (Array.isArray(message)) {
+            for (const item of message) {
+                await this.handleMessage(item);
+            }
+            return;
+        }
+        await this.handleMessage(message);
+    }
+    async handleMessage(message) {
+        if (!isObject(message) || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+            if (!isObject(message) || !('result' in message || 'error' in message)) {
+                this.error(isObject(message) && 'id' in message ? message.id : null, ERR.invalidRequest, 'Invalid request');
+            }
+            return;
+        }
+        const request = message;
+        const isNotification = !('id' in request) || request.id === undefined;
+        try {
+            const result = await this.dispatch(request);
+            if (!isNotification) {
+                this.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result }));
+            }
+        }
+        catch (e) {
+            if (isNotification) {
+                return;
+            }
+            if (e instanceof RpcError) {
+                this.error(request.id ?? null, e.code, e.message);
+            }
+            else {
+                process.stderr.write(`[codesprint] ${e.stack ?? String(e)}\n`);
+                this.error(request.id ?? null, ERR.internal, 'Internal error');
+            }
+        }
+    }
+    async dispatch(req) {
+        const params = req.params ?? {};
+        switch (req.method) {
+            case 'initialize': {
+                const requested = typeof params.protocolVersion === 'string' ? params.protocolVersion : '';
+                const version = exports.SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+                    ? requested
+                    : exports.SUPPORTED_PROTOCOL_VERSIONS[0];
+                return {
+                    protocolVersion: version,
+                    capabilities: { tools: { listChanged: false }, prompts: { listChanged: false } },
+                    serverInfo: { name: this.info.name, title: this.info.title, version: this.info.version },
+                    ...(this.info.instructions ? { instructions: this.info.instructions } : {}),
+                };
+            }
+            case 'ping':
+                return {};
+            case 'notifications/initialized':
+            case 'notifications/cancelled':
+                return undefined;
+            case 'tools/list':
+                return {
+                    tools: [...this.tools.values()].map(({ name, title, description, inputSchema, annotations }) => ({
+                        name, title, description, inputSchema, annotations,
+                    })),
+                };
+            case 'tools/call':
+                return this.callTool(params);
+            case 'prompts/list':
+                return { prompts: [...this.prompts.values()].map(({ name, title, description }) => ({ name, title, description })) };
+            case 'prompts/get':
+                return this.getPrompt(params);
+            default:
+                throw new RpcError(ERR.notFound, `Method not found: ${req.method}`);
+        }
+    }
+    async callTool(params) {
+        const tool = typeof params.name === 'string' ? this.tools.get(params.name) : undefined;
+        if (!tool) {
+            throw new RpcError(ERR.invalidParams, `Unknown tool: ${String(params.name)}`);
+        }
+        const args = isObject(params.arguments) ? params.arguments : {};
+        try {
+            const text = await tool.handler(args);
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: e.message }], isError: true };
+        }
+    }
+    async getPrompt(params) {
+        const prompt = typeof params.name === 'string' ? this.prompts.get(params.name) : undefined;
+        if (!prompt) {
+            throw new RpcError(ERR.invalidParams, `Unknown prompt: ${String(params.name)}`);
+        }
+        const text = await prompt.handler();
+        return { description: prompt.description, messages: [{ role: 'user', content: { type: 'text', text } }] };
+    }
+    error(id, code, message) {
+        this.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }));
+    }
+}
+exports.McpServer = McpServer;
+class RpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "codesprint-mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "CodeSprint focus timer, daily goals, streaks and stats as a Model Context Protocol server for the Zed editor.",
+  "license": "MIT",
+  "author": "CodeSprint Contributors <harshitkishoresingh26@gmail.com>",
+  "repository": { "type": "git", "url": "git+https://github.com/harshitsingh205/codesprint-zed.git", "directory": "server" },
+  "bugs": { "url": "https://github.com/harshitsingh205/codesprint-zed/issues" },
+  "homepage": "https://github.com/harshitsingh205/codesprint-zed#readme",
+  "keywords": ["zed", "mcp", "model-context-protocol", "pomodoro", "focus", "timer", "productivity"],
+  "bin": { "codesprint-mcp-server": "dist/index.js" },
+  "main": "dist/index.js",
+  "files": ["dist", "README.md", "LICENSE"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node scripts/run-tests.js",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "typescript": "^5.9.3"
+  }
+}