mcp-intervals 1.0.2 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Edu Calvo
+
+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/README.md

@@ -5,7 +5,22 @@
 
 MCP server for [Intervals](https://www.myintervals.com/) task management. Lets Claude read and update tasks, add notes, and browse projects and milestones directly from your Intervals account.
 
-## Setup
+## Quick Start
+
+Run the interactive installer:
+
+```bash
+npx mcp-intervals init
+```
+
+This will:
+1. Detect installed MCP clients (Claude Code, Claude Desktop, Cursor, Windsurf)
+2. Let you select which clients to configure
+3. Prompt for your Intervals API token
+4. Validate the token with your Intervals account
+5. Save the configuration automatically
+
+## Manual Setup
 
 ### 1. Get your Intervals API token
 
@@ -93,21 +108,24 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 
 ## Available Tools
 
-| Tool             | Description                                                       |
-| ---------------- | ----------------------------------------------------------------- |
-| `get_task`       | Get task details by local ID or Intervals URL                     |
-| `update_task`    | Update task status, assignee, priority, title, due date, or owner |
-| `add_task_note`  | Add a comment/note to a task (supports HTML)                      |
-| `get_task_notes` | Retrieve all comments/notes on a task                             |
-| `get_project`    | Get project details (name, client, dates, budget)                 |
-| `get_milestone`  | Get milestone details (title, due date, progress)                 |
+| Tool               | Description                                                                  |
+| ------------------ | ---------------------------------------------------------------------------- |
+| `get_task`         | Get task details by local ID or Intervals URL                                |
+| `update_task`      | Update task status, assignee, priority, title, description, due date, owner  |
+| `add_task_note`    | Add a comment/note to a task (supports HTML)                                 |
+| `get_task_notes`   | Retrieve all comments/notes on a task                                        |
+| `add_time_entry`   | Add a time entry to a task (billable/unbillable with work type)              |
+| `get_time_entries` | Retrieve time entries (filter by task, date range)                           |
+| `get_project`      | Get project details (name, client, dates, budget)                            |
+| `get_milestone`    | Get milestone details (title, due date, progress)                            |
 
 ## Resources
 
-| Resource        | URI                      | Description                                         |
-| --------------- | ------------------------ | --------------------------------------------------- |
-| Task Statuses   | `intervals://statuses`   | List of all status IDs for use with `update_task`   |
-| Task Priorities | `intervals://priorities` | List of all priority IDs for use with `update_task` |
+| Resource        | URI                      | Description                                           |
+| --------------- | ------------------------ | ----------------------------------------------------- |
+| Task Statuses   | `intervals://statuses`   | List of all status IDs for use with `update_task`     |
+| Task Priorities | `intervals://priorities` | List of all priority IDs for use with `update_task`   |
+| Work Types      | `intervals://worktypes`  | List of all work type IDs for use with time entries   |
 
 ## Example Usage
 
@@ -115,8 +133,12 @@ Once installed, you can ask Claude things like:
 
 - "Get the details of task 1234"
 - "Update task 1234 status to closed"
+- "Update the description of task 1234 to explain the new requirements"
 - "Add a note to task 1234 saying the fix has been deployed"
 - "Show me all notes on task 1234"
+- "Log 2 hours of billable time on task 1234 for today"
+- "Add 30 minutes of unbillable time to task 1234 for code review"
+- "Show me all time entries for task 1234"
 - "What are the details of project 5?"
 
 ## License

package/dist/cli/api.d.ts

@@ -0,0 +1,6 @@
+export interface ValidationResult {
+    valid: boolean;
+    workspace?: string;
+    error?: string;
+}
+export declare function validateToken(token: string): Promise<ValidationResult>;

package/dist/cli/api.js

@@ -0,0 +1,28 @@
+export async function validateToken(token) {
+    try {
+        const authHeader = "Basic " + Buffer.from(`${token}:X`).toString("base64");
+        const response = await fetch("https://api.myintervals.com/me/", {
+            headers: {
+                Authorization: authHeader,
+                Accept: "application/json",
+            },
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            return {
+                valid: true,
+                workspace: data.me?.company || "Unknown workspace",
+            };
+        }
+        if (response.status === 401) {
+            return { valid: false, error: "Invalid API token" };
+        }
+        return { valid: false, error: `API error: ${response.status}` };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("fetch")) {
+            return { valid: false, error: "Network error - could not reach Intervals API" };
+        }
+        return { valid: false, error: String(error) };
+    }
+}

package/dist/cli/clients.d.ts

@@ -0,0 +1,21 @@
+export interface McpClient {
+    id: string;
+    name: string;
+    configPath: string;
+    detected: boolean;
+}
+interface McpConfig {
+    mcpServers?: Record<string, McpServerConfig>;
+    [key: string]: unknown;
+}
+interface McpServerConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export declare function detectClients(): McpClient[];
+export declare function readConfig(configPath: string): McpConfig;
+export declare function writeConfig(configPath: string, config: McpConfig): void;
+export declare function configureClient(configPath: string, token: string): void;
+export declare function hasExistingConfig(configPath: string): boolean;
+export {};

package/dist/cli/clients.js

@@ -0,0 +1,136 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getClientPaths() {
+    const platform = os.platform();
+    const home = os.homedir();
+    const clients = [];
+    // Claude Code (global)
+    clients.push({
+        id: "claude-code-global",
+        name: "Claude Code (global)",
+        path: path.join(home, ".claude.json"),
+    });
+    // Claude Code (project)
+    clients.push({
+        id: "claude-code-project",
+        name: "Claude Code (project)",
+        path: path.join(process.cwd(), ".mcp.json"),
+    });
+    // Claude Desktop
+    if (platform === "darwin") {
+        clients.push({
+            id: "claude-desktop",
+            name: "Claude Desktop",
+            path: path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+        });
+    }
+    else if (platform === "win32") {
+        clients.push({
+            id: "claude-desktop",
+            name: "Claude Desktop",
+            path: path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json"),
+        });
+    }
+    // Cursor
+    if (platform === "darwin" || platform === "linux") {
+        clients.push({
+            id: "cursor",
+            name: "Cursor",
+            path: path.join(home, ".cursor", "mcp.json"),
+        });
+    }
+    else if (platform === "win32") {
+        clients.push({
+            id: "cursor",
+            name: "Cursor",
+            path: path.join(home, ".cursor", "mcp.json"),
+        });
+    }
+    // Windsurf
+    if (platform === "darwin" || platform === "linux") {
+        clients.push({
+            id: "windsurf",
+            name: "Windsurf",
+            path: path.join(home, ".codeium", "windsurf", "mcp_config.json"),
+        });
+    }
+    else if (platform === "win32") {
+        clients.push({
+            id: "windsurf",
+            name: "Windsurf",
+            path: path.join(process.env.APPDATA || "", "Codeium", "windsurf", "mcp_config.json"),
+        });
+    }
+    return clients;
+}
+export function detectClients() {
+    const clientPaths = getClientPaths();
+    return clientPaths.map((client) => {
+        let detected = false;
+        // Check if file exists OR if parent directory exists (we can create the file)
+        if (fs.existsSync(client.path)) {
+            detected = true;
+        }
+        else {
+            const parentDir = path.dirname(client.path);
+            if (fs.existsSync(parentDir)) {
+                detected = true;
+            }
+        }
+        return {
+            id: client.id,
+            name: client.name,
+            configPath: client.path,
+            detected,
+        };
+    });
+}
+export function readConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${configPath}`);
+    }
+}
+export function writeConfig(configPath, config) {
+    const dir = path.dirname(configPath);
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Create backup if file exists
+    if (fs.existsSync(configPath)) {
+        const backupPath = configPath + ".bak";
+        fs.copyFileSync(configPath, backupPath);
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+export function configureClient(configPath, token) {
+    const config = readConfig(configPath);
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+    config.mcpServers.intervals = {
+        command: "npx",
+        args: ["-y", "mcp-intervals"],
+        env: {
+            INTERVALS_API_TOKEN: token,
+        },
+    };
+    writeConfig(configPath, config);
+}
+export function hasExistingConfig(configPath) {
+    try {
+        const config = readConfig(configPath);
+        return config.mcpServers?.intervals !== undefined;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/init.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { detectClients, configureClient, hasExistingConfig } from "./clients.js";
+import { validateToken } from "./api.js";
+import { searchMultiselect, cancelSymbol } from "./prompts/search-multiselect.js";
+// Logo ASCII art with gradient grays (256-color)
+const LOGO_LINES = [
+    "██╗███╗   ██╗████████╗███████╗██████╗ ██╗   ██╗ █████╗ ██╗     ███████╗",
+    "██║████╗  ██║╚══██╔══╝██╔════╝██╔══██╗██║   ██║██╔══██╗██║     ██╔════╝",
+    "██║██╔██╗ ██║   ██║   █████╗  ██████╔╝██║   ██║███████║██║     ███████╗",
+    "██║██║╚██╗██║   ██║   ██╔══╝  ██╔══██╗╚██╗ ██╔╝██╔══██║██║     ╚════██║",
+    "██║██║ ╚████║   ██║   ███████╗██║  ██║ ╚████╔╝ ██║  ██║███████╗███████║",
+    "╚═╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝╚══════╝╚══════╝",
+];
+// 256-color grays for gradient effect
+const GRAYS = [
+    "\x1b[38;5;250m", // lighter
+    "\x1b[38;5;248m",
+    "\x1b[38;5;245m",
+    "\x1b[38;5;243m",
+    "\x1b[38;5;240m",
+    "\x1b[38;5;238m", // darker
+];
+const RESET = "\x1b[0m";
+function showLogo() {
+    console.log();
+    LOGO_LINES.forEach((line, i) => {
+        console.log(`${GRAYS[i]}${line}${RESET}`);
+    });
+}
+function shortenPath(fullPath) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (home && fullPath.startsWith(home)) {
+        return "~" + fullPath.slice(home.length);
+    }
+    return fullPath;
+}
+async function main() {
+    showLogo();
+    console.log();
+    p.intro(pc.bgCyan(pc.black(" intervals ")));
+    const spinner = p.spinner();
+    // Detect clients
+    spinner.start("Detecting MCP clients...");
+    const clients = detectClients();
+    const detectedClients = clients.filter((c) => c.detected);
+    const notFoundClients = clients.filter((c) => !c.detected);
+    spinner.stop(`${detectedClients.length} clients found`);
+    // Show detection results
+    console.log();
+    p.log.message(pc.bold("Found installed clients:"));
+    for (const client of detectedClients) {
+        p.log.message(`  ${pc.green("✓")} ${client.name}`);
+    }
+    for (const client of notFoundClients) {
+        p.log.message(`  ${pc.dim("✗")} ${pc.dim(client.name + " (not found)")}`);
+    }
+    if (detectedClients.length === 0) {
+        p.cancel("No MCP clients detected. Install Claude Code, Claude Desktop, Cursor, or Windsurf first.");
+        process.exit(1);
+    }
+    // Select clients with search multiselect
+    const clientChoices = detectedClients.map((client) => {
+        const hasExisting = hasExistingConfig(client.configPath);
+        return {
+            value: client.id,
+            label: client.name,
+            hint: shortenPath(client.configPath) + (hasExisting ? " - will overwrite" : ""),
+        };
+    });
+    // Pre-select clients that don't have existing config
+    const initialSelected = detectedClients
+        .filter((c) => !hasExistingConfig(c.configPath))
+        .map((c) => c.id);
+    console.log();
+    const selectedIds = await searchMultiselect({
+        message: "Which clients do you want to configure?",
+        items: clientChoices,
+        initialSelected: initialSelected.length > 0 ? initialSelected : [detectedClients[0]?.id].filter(Boolean),
+        required: true,
+    });
+    if (selectedIds === cancelSymbol || (Array.isArray(selectedIds) && selectedIds.length === 0)) {
+        p.cancel("Installation cancelled");
+        process.exit(0);
+    }
+    const selectedClients = detectedClients.filter((c) => Array.isArray(selectedIds) && selectedIds.includes(c.id));
+    // Get API token
+    console.log();
+    const token = await p.password({
+        message: "Enter your Intervals API token:",
+    });
+    if (p.isCancel(token) || !token || token.trim() === "") {
+        p.cancel("No token provided");
+        process.exit(1);
+    }
+    // Validate token
+    spinner.start("Validating token...");
+    const validation = await validateToken(token.trim());
+    if (!validation.valid) {
+        spinner.stop(pc.red("Token validation failed"));
+        p.log.error(validation.error || "Invalid token");
+        p.log.message(pc.dim("  Find your API token at: https://[subdomain].myintervals.com/account/api/"));
+        console.log();
+        const continueAnyway = await p.confirm({
+            message: "Save configuration anyway (without validation)?",
+            initialValue: false,
+        });
+        if (p.isCancel(continueAnyway) || !continueAnyway) {
+            p.cancel("Installation cancelled");
+            process.exit(1);
+        }
+    }
+    else {
+        spinner.stop(`Token valid! Connected to "${validation.workspace}"`);
+    }
+    // Show summary and confirm
+    console.log();
+    const summaryLines = [];
+    for (const client of selectedClients) {
+        summaryLines.push(`${pc.cyan(client.name)}  ${pc.dim(shortenPath(client.configPath))}`);
+    }
+    p.note(summaryLines.join("\n"), "Will configure");
+    const confirmed = await p.confirm({
+        message: "Proceed with configuration?",
+        initialValue: true,
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        process.exit(0);
+    }
+    // Configure each client
+    spinner.start("Saving configuration...");
+    const results = [];
+    for (const client of selectedClients) {
+        try {
+            configureClient(client.configPath, token.trim());
+            results.push({ client: client.name, success: true });
+        }
+        catch (error) {
+            results.push({
+                client: client.name,
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    spinner.stop("Configuration complete");
+    // Show results
+    console.log();
+    if (successful.length > 0) {
+        const resultLines = successful.map((r) => {
+            const client = selectedClients.find((c) => c.name === r.client);
+            return `${pc.green("✓")} ${r.client}  ${pc.dim(client ? shortenPath(client.configPath) : "")}`;
+        });
+        p.note(resultLines.join("\n"), pc.green(`Configured ${successful.length} client${successful.length !== 1 ? "s" : ""}`));
+    }
+    if (failed.length > 0) {
+        console.log();
+        p.log.error(pc.red(`Failed to configure ${failed.length} client${failed.length !== 1 ? "s" : ""}:`));
+        for (const r of failed) {
+            p.log.message(`  ${pc.red("✗")} ${r.client}: ${pc.dim(r.error)}`);
+        }
+    }
+    console.log();
+    p.outro(pc.green("Done! Restart your MCP clients to use mcp-intervals."));
+}
+main().catch((error) => {
+    p.log.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+});

package/dist/cli/prompts/search-multiselect.d.ts

@@ -0,0 +1,14 @@
+export interface SearchItem<T> {
+    value: T;
+    label: string;
+    hint?: string;
+}
+export interface SearchMultiselectOptions<T> {
+    message: string;
+    items: SearchItem<T>[];
+    maxVisible?: number;
+    initialSelected?: T[];
+    required?: boolean;
+}
+export declare const cancelSymbol: unique symbol;
+export declare function searchMultiselect<T>(options: SearchMultiselectOptions<T>): Promise<T[] | symbol>;

package/dist/cli/prompts/search-multiselect.js

@@ -0,0 +1,190 @@
+import * as readline from "readline";
+import { Writable } from "stream";
+import pc from "picocolors";
+// Silent writable stream to prevent readline from echoing input
+const silentOutput = new Writable({
+    write(_chunk, _encoding, callback) {
+        callback();
+    },
+});
+const S_STEP_ACTIVE = pc.green("◆");
+const S_STEP_CANCEL = pc.red("■");
+const S_STEP_SUBMIT = pc.green("◇");
+const S_RADIO_ACTIVE = pc.green("●");
+const S_RADIO_INACTIVE = pc.dim("○");
+const S_BAR = pc.dim("│");
+export const cancelSymbol = Symbol("cancel");
+export async function searchMultiselect(options) {
+    const { message, items, maxVisible = 8, initialSelected = [], required = false } = options;
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: silentOutput,
+            terminal: false,
+        });
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        readline.emitKeypressEvents(process.stdin, rl);
+        let query = "";
+        let cursor = 0;
+        const selected = new Set(initialSelected);
+        let lastRenderHeight = 0;
+        const filter = (item, q) => {
+            if (!q)
+                return true;
+            const lowerQ = q.toLowerCase();
+            return (item.label.toLowerCase().includes(lowerQ) ||
+                String(item.value).toLowerCase().includes(lowerQ));
+        };
+        const getFiltered = () => {
+            return items.filter((item) => filter(item, query));
+        };
+        const clearRender = () => {
+            if (lastRenderHeight > 0) {
+                process.stdout.write(`\x1b[${lastRenderHeight}A`);
+                for (let i = 0; i < lastRenderHeight; i++) {
+                    process.stdout.write("\x1b[2K\x1b[1B");
+                }
+                process.stdout.write(`\x1b[${lastRenderHeight}A`);
+            }
+        };
+        const render = (state = "active") => {
+            clearRender();
+            const lines = [];
+            const filtered = getFiltered();
+            const icon = state === "active" ? S_STEP_ACTIVE : state === "cancel" ? S_STEP_CANCEL : S_STEP_SUBMIT;
+            lines.push(`${icon}  ${pc.bold(message)}`);
+            if (state === "active") {
+                const searchLine = `${S_BAR}  ${pc.dim("Search:")} ${query}${pc.inverse(" ")}`;
+                lines.push(searchLine);
+                lines.push(`${S_BAR}  ${pc.dim("↑↓ move, space select, enter confirm")}`);
+                lines.push(`${S_BAR}`);
+                const visibleStart = Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), filtered.length - maxVisible));
+                const visibleEnd = Math.min(filtered.length, visibleStart + maxVisible);
+                const visibleItems = filtered.slice(visibleStart, visibleEnd);
+                if (filtered.length === 0) {
+                    lines.push(`${S_BAR}  ${pc.dim("No matches found")}`);
+                }
+                else {
+                    for (let i = 0; i < visibleItems.length; i++) {
+                        const item = visibleItems[i];
+                        const actualIndex = visibleStart + i;
+                        const isSelected = selected.has(item.value);
+                        const isCursor = actualIndex === cursor;
+                        const radio = isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE;
+                        const label = isCursor ? pc.underline(item.label) : item.label;
+                        const hint = item.hint ? pc.dim(` (${item.hint})`) : "";
+                        const prefix = isCursor ? pc.cyan("❯") : " ";
+                        lines.push(`${S_BAR} ${prefix} ${radio} ${label}${hint}`);
+                    }
+                    const hiddenBefore = visibleStart;
+                    const hiddenAfter = filtered.length - visibleEnd;
+                    if (hiddenBefore > 0 || hiddenAfter > 0) {
+                        const parts = [];
+                        if (hiddenBefore > 0)
+                            parts.push(`↑ ${hiddenBefore} more`);
+                        if (hiddenAfter > 0)
+                            parts.push(`↓ ${hiddenAfter} more`);
+                        lines.push(`${S_BAR}  ${pc.dim(parts.join("  "))}`);
+                    }
+                }
+                lines.push(`${S_BAR}`);
+                if (selected.size === 0) {
+                    lines.push(`${S_BAR}  ${pc.dim("Selected: (none)")}`);
+                }
+                else {
+                    const selectedLabels = items
+                        .filter((item) => selected.has(item.value))
+                        .map((item) => item.label);
+                    const summary = selectedLabels.length <= 3
+                        ? selectedLabels.join(", ")
+                        : `${selectedLabels.slice(0, 3).join(", ")} +${selectedLabels.length - 3} more`;
+                    lines.push(`${S_BAR}  ${pc.green("Selected:")} ${summary}`);
+                }
+                lines.push(`${pc.dim("└")}`);
+            }
+            else if (state === "submit") {
+                const selectedLabels = items
+                    .filter((item) => selected.has(item.value))
+                    .map((item) => item.label);
+                lines.push(`${S_BAR}  ${pc.dim(selectedLabels.join(", "))}`);
+            }
+            else if (state === "cancel") {
+                lines.push(`${S_BAR}  ${pc.strikethrough(pc.dim("Cancelled"))}`);
+            }
+            process.stdout.write(lines.join("\n") + "\n");
+            lastRenderHeight = lines.length;
+        };
+        const cleanup = () => {
+            process.stdin.removeListener("keypress", keypressHandler);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            rl.close();
+        };
+        const submit = () => {
+            if (required && selected.size === 0) {
+                return;
+            }
+            render("submit");
+            cleanup();
+            resolve(Array.from(selected));
+        };
+        const cancel = () => {
+            render("cancel");
+            cleanup();
+            resolve(cancelSymbol);
+        };
+        const keypressHandler = (_str, key) => {
+            if (!key)
+                return;
+            const filtered = getFiltered();
+            if (key.name === "return") {
+                submit();
+                return;
+            }
+            if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+                cancel();
+                return;
+            }
+            if (key.name === "up") {
+                cursor = Math.max(0, cursor - 1);
+                render();
+                return;
+            }
+            if (key.name === "down") {
+                cursor = Math.min(filtered.length - 1, cursor + 1);
+                render();
+                return;
+            }
+            if (key.name === "space") {
+                const item = filtered[cursor];
+                if (item) {
+                    if (selected.has(item.value)) {
+                        selected.delete(item.value);
+                    }
+                    else {
+                        selected.add(item.value);
+                    }
+                }
+                render();
+                return;
+            }
+            if (key.name === "backspace") {
+                query = query.slice(0, -1);
+                cursor = 0;
+                render();
+                return;
+            }
+            if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+                query += key.sequence;
+                cursor = 0;
+                render();
+                return;
+            }
+        };
+        process.stdin.on("keypress", keypressHandler);
+        render();
+    });
+}

package/dist/client.d.ts

@@ -18,4 +18,20 @@ export declare class IntervalsClient {
     getMilestone(id: number): Promise<Record<string, unknown>>;
     getTaskStatuses(): Promise<Record<string, unknown>>;
     getTaskPriorities(): Promise<Record<string, unknown>>;
+    getWorkTypes(): Promise<Record<string, unknown>>;
+    addTimeEntry(fields: {
+        taskid: number;
+        worktypeid: number;
+        date: string;
+        time: number;
+        billable: boolean;
+        description?: string;
+    }): Promise<Record<string, unknown>>;
+    getTimeEntries(params?: {
+        taskid?: number;
+        personid?: number;
+        datebegin?: string;
+        dateend?: string;
+    }): Promise<Record<string, unknown>>;
+    getMe(): Promise<Record<string, unknown>>;
 }

package/dist/client.js

@@ -82,4 +82,37 @@ export class IntervalsClient {
         const data = await this.request(`/taskpriority/`);
         return data;
     }
+    // --- Work Types ---
+    async getWorkTypes() {
+        const data = await this.request(`/worktype/`);
+        return data;
+    }
+    // --- Time Entries ---
+    async addTimeEntry(fields) {
+        // First get the current user's person ID
+        const me = await this.getMe();
+        const personid = me.personid;
+        const data = await this.request(`/time/`, {
+            method: "POST",
+            body: {
+                taskid: fields.taskid,
+                worktypeid: fields.worktypeid,
+                personid,
+                date: fields.date,
+                time: fields.time,
+                billable: fields.billable,
+                ...(fields.description && { description: fields.description }),
+            },
+        });
+        return data;
+    }
+    async getTimeEntries(params = {}) {
+        const data = await this.request(`/time/`, { params: params });
+        return data;
+    }
+    // --- Me (current user) ---
+    async getMe() {
+        const data = await this.request(`/me/`);
+        return data.me;
+    }
 }

package/dist/index.js

@@ -1,26 +1,31 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { IntervalsClient } from "./client.js";
-import { registerTools } from "./tools.js";
-import { registerResources } from "./resources.js";
-const API_TOKEN = process.env.INTERVALS_API_TOKEN;
-if (!API_TOKEN) {
-    console.error("Error: INTERVALS_API_TOKEN environment variable is required.");
-    process.exit(1);
+// Handle CLI subcommands
+if (process.argv[2] === "init") {
+    import("./cli/init.js");
 }
-const client = new IntervalsClient(API_TOKEN);
-const server = new McpServer({
-    name: "mcp-intervals",
-    version: "1.0.0",
-});
-registerTools(server, client);
-registerResources(server, client);
-async function main() {
+else {
+    // MCP Server mode
+    startServer();
+}
+async function startServer() {
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const { IntervalsClient } = await import("./client.js");
+    const { registerTools } = await import("./tools.js");
+    const { registerResources } = await import("./resources.js");
+    const API_TOKEN = process.env.INTERVALS_API_TOKEN;
+    if (!API_TOKEN) {
+        console.error("Error: INTERVALS_API_TOKEN environment variable is required.");
+        process.exit(1);
+    }
+    const client = new IntervalsClient(API_TOKEN);
+    const server = new McpServer({
+        name: "mcp-intervals",
+        version: "1.0.0",
+    });
+    registerTools(server, client);
+    registerResources(server, client);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
-main().catch((error) => {
-    console.error("Fatal error:", error);
-    process.exit(1);
-});
+export {};

package/dist/resources.js

@@ -31,4 +31,20 @@ export function registerResources(server, client) {
             ],
         };
     });
+    // --- Work Types ---
+    server.resource("work-types", "intervals://worktypes", {
+        description: "List of all work types with their IDs. Use these IDs when adding a time entry.",
+        mimeType: "application/json",
+    }, async () => {
+        const data = await client.getWorkTypes();
+        return {
+            contents: [
+                {
+                    uri: "intervals://worktypes",
+                    mimeType: "application/json",
+                    text: JSON.stringify(data, null, 2),
+                },
+            ],
+        };
+    });
 }

package/dist/tools.js

@@ -16,7 +16,7 @@ export function registerTools(server, client) {
         };
     });
     // --- update_task ---
-    server.tool("update_task", "Update fields on an Intervals task (status, assignee, priority, title, due date, owner).", {
+    server.tool("update_task", "Update fields on an Intervals task (status, assignee, priority, title, description, due date, owner).", {
         taskId: z.number().describe("The local task ID (as shown in the Intervals web UI)"),
         statusid: z
             .number()
@@ -31,6 +31,10 @@ export function registerTools(server, client) {
             .optional()
             .describe("New priority ID (use intervals://priorities resource for valid IDs)"),
         title: z.string().optional().describe("New task title"),
+        summary: z
+            .string()
+            .optional()
+            .describe("New task description/summary (HTML is accepted)"),
         datedue: z
             .string()
             .optional()
@@ -124,4 +128,71 @@ export function registerTools(server, client) {
             ],
         };
     });
+    // --- add_time_entry ---
+    server.tool("add_time_entry", "Add a time entry to an Intervals task. Records time worked as billable or unbillable with a specific work type.", {
+        taskId: z
+            .number()
+            .describe("The local task ID (as shown in the Intervals web UI)"),
+        worktypeid: z
+            .number()
+            .describe("Work type ID (use intervals://worktypes resource for valid IDs)"),
+        date: z
+            .string()
+            .describe("Date of the time entry in YYYY-MM-DD format"),
+        time: z
+            .number()
+            .describe("Time worked in decimal hours (e.g., 1.5 for 1 hour 30 minutes)"),
+        billable: z
+            .boolean()
+            .describe("Whether the time is billable (true) or unbillable (false)"),
+        description: z
+            .string()
+            .optional()
+            .describe("Optional description of work performed"),
+    }, async ({ taskId, worktypeid, date, time, billable, description }) => {
+        const internalId = await client.resolveTaskId(taskId);
+        const data = await client.addTimeEntry({
+            taskid: internalId,
+            worktypeid,
+            date,
+            time,
+            billable,
+            description,
+        });
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // --- get_time_entries ---
+    server.tool("get_time_entries", "Retrieve time entries from Intervals. Can filter by task, person, or date range.", {
+        taskId: z
+            .number()
+            .optional()
+            .describe("Filter by local task ID (as shown in the Intervals web UI)"),
+        datebegin: z
+            .string()
+            .optional()
+            .describe("Start date filter in YYYY-MM-DD format"),
+        dateend: z
+            .string()
+            .optional()
+            .describe("End date filter in YYYY-MM-DD format"),
+    }, async ({ taskId, datebegin, dateend }) => {
+        let internalTaskId;
+        if (taskId) {
+            internalTaskId = await client.resolveTaskId(taskId);
+        }
+        const data = await client.getTimeEntries({
+            taskid: internalTaskId,
+            datebegin,
+            dateend,
+        });
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "mcp-intervals",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "MCP server for Intervals task management",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "mcp-intervals": "dist/index.js"
+    "mcp-intervals": "dist/index.js",
+    "mcp-intervals-init": "dist/cli/init.js"
   },
   "files": [
     "dist"
@@ -28,7 +29,9 @@
     "url": "https://github.com/educlopez/mcp-intervals.git"
   },
   "dependencies": {
+    "@clack/prompts": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "picocolors": "^1.1.1",
     "zod": "^3.24.2"
   },
   "devDependencies": {