@1medium/cli 1.0.0

package/README.md

@@ -0,0 +1,158 @@
+# @1medium/cli
+
+Command-line interface for 1Medium AI coding agent integration.
+
+## Installation
+
+```bash
+# From npm (when published)
+npm install -g @1medium/cli
+
+# From source
+cd packages/cli
+npm install
+npm link
+```
+
+## Configuration
+
+Set your API token:
+
+```bash
+# Interactive
+1m login
+
+# With token directly
+1m login --token 1m_pat_xxxxxxxxxxxxx
+
+# Or via environment variable
+export ONEMEDIUM_TOKEN=1m_pat_xxxxxxxxxxxxx
+```
+
+## Usage
+
+### Authentication
+
+```bash
+# Check current token and rate limits
+1m whoami
+
+# View configuration
+1m config
+
+# Remove credentials
+1m logout
+```
+
+### Task Management
+
+```bash
+# Create a task
+1m task add --title "Fix authentication bug in login flow" \
+  --body "The login form fails when..." \
+  --priority P1 \
+  --repo owner/repo \
+  --branch feature/auth-fix
+
+# List tasks
+1m task list
+1m task list --status open --priority P0
+1m task list --repo owner/repo --created-by agent
+
+# Get task details
+1m task get <task-id>
+
+# Update a task
+1m task update <task-id> --status doing --add-tag in-progress
+
+# Add a comment
+1m task comment <task-id> --message "Started working on this"
+
+# Mark as complete
+1m task done <task-id> --message "Fixed in commit abc123"
+```
+
+### JSON Output
+
+All commands support `--json` flag for machine-readable output:
+
+```bash
+1m task list --json
+1m task get <id> --json
+```
+
+## Environment Variables
+
+- `ONEMEDIUM_TOKEN` - API token (overrides stored config)
+- `ONEMEDIUM_API_URL` - API base URL (default: https://1medium.ai/api)
+
+## MCP Server (Claude Code Integration)
+
+This package includes an MCP (Model Context Protocol) server for direct integration with Claude Code.
+
+### Setup
+
+Add to your Claude Code MCP config (`~/.claude.json`):
+
+```json
+{
+  "mcpServers": {
+    "1medium": {
+      "command": "1m-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Code, and it will have access to these tools:
+
+| Tool | Description |
+|------|-------------|
+| `task_create` | Create tasks with title, body, priority |
+| `task_list` | List tasks filtered by status/priority |
+| `task_get` | Get full task details |
+| `task_update` | Update task properties |
+| `task_complete` | Mark task as done |
+| `task_comment` | Add comments/updates |
+
+### Usage
+
+Once configured, ask Claude Code things like:
+
+- "Create a task to fix the authentication bug"
+- "Show me my P1 tasks"
+- "Mark task ABC as complete"
+- "Add a comment to task XYZ saying I'm working on it"
+
+## For AI Agents
+
+The CLI is designed for use by AI coding agents like Claude Code, Cursor, and Copilot.
+
+Example workflow for an AI agent:
+
+```bash
+# Agent creates task for discovered issue
+1m task add --title "Security: SQL injection in user search" \
+  --body "Found potential SQL injection in /api/users/search..." \
+  --priority P0 \
+  --repo myorg/myapp \
+  --file "src/api/users.js" \
+  --source "claude-code"
+
+# Agent updates progress
+1m task comment <id> --message "Implemented parameterized queries"
+
+# Agent marks complete
+1m task done <id> --message "Fixed in PR #123"
+```
+
+## Getting Your API Token
+
+1. Go to [1medium.ai](https://1medium.ai)
+2. Navigate to Settings > API Tokens
+3. Create a new agent token
+4. Run `1m login --token YOUR_TOKEN`
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@1medium/cli",
+  "version": "1.0.0",
+  "description": "CLI and MCP server for 1Medium AI task management",
+  "main": "src/index.js",
+  "bin": {
+    "1m": "./src/index.js",
+    "1m-mcp": "./src/mcp-server.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "1medium",
+    "cli",
+    "mcp",
+    "claude",
+    "agent",
+    "task-management",
+    "model-context-protocol"
+  ],
+  "author": "1Medium <support@1medium.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1medium/cli.git"
+  },
+  "homepage": "https://1medium.ai",
+  "bugs": {
+    "url": "https://github.com/1medium/cli/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "conf": "^10.2.0",
+    "dotenv": "^16.3.1",
+    "node-fetch": "^2.7.0",
+    "ora": "^5.4.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,139 @@
+"use strict";
+
+const fetch = require("node-fetch");
+const config = require("./config");
+
+/**
+ * Get API base URL
+ */
+function getApiUrl() {
+  return config.get("apiUrl") || "https://1medium.ai/api";
+}
+
+/**
+ * Get auth token
+ */
+function getToken() {
+  const token = config.get("token");
+  if (!token) {
+    throw new Error(
+      "No token configured. Run '1m login' to set your API token."
+    );
+  }
+  return token;
+}
+
+/**
+ * Make an authenticated API request
+ */
+async function request(method, path, body = null, params = null) {
+  const baseUrl = getApiUrl();
+  const token = getToken();
+
+  let url = `${baseUrl}/v1/agent${path}`;
+  if (params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, value);
+      }
+    }
+    const queryString = searchParams.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+  }
+
+  const options = {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "User-Agent": "1m-cli/1.0.0",
+    },
+  };
+
+  if (body && (method === "POST" || method === "PATCH" || method === "PUT")) {
+    options.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(url, options);
+  const data = await response.json();
+
+  if (!response.ok) {
+    const message = data.message || data.error || "API request failed";
+    const error = new Error(message);
+    error.statusCode = response.status;
+    error.details = data.details;
+    throw error;
+  }
+
+  return data;
+}
+
+/**
+ * Token introspection
+ */
+async function whoami() {
+  return request("GET", "/whoami");
+}
+
+/**
+ * Create a task
+ */
+async function createTask(payload) {
+  return request("POST", "/tasks", payload);
+}
+
+/**
+ * List tasks
+ */
+async function listTasks(params = {}) {
+  return request("GET", "/tasks", null, params);
+}
+
+/**
+ * Get a single task
+ */
+async function getTask(id) {
+  return request("GET", `/tasks/${id}`);
+}
+
+/**
+ * Update a task
+ */
+async function updateTask(id, payload) {
+  return request("PATCH", `/tasks/${id}`, payload);
+}
+
+/**
+ * Add a comment to a task
+ */
+async function addComment(taskId, payload) {
+  return request("POST", `/tasks/${taskId}/comments`, payload);
+}
+
+/**
+ * Complete a task
+ */
+async function completeTask(taskId, payload = {}) {
+  return request("POST", `/tasks/${taskId}/complete`, payload);
+}
+
+/**
+ * List organizations
+ */
+async function listOrgs() {
+  return request("GET", "/orgs");
+}
+
+module.exports = {
+  whoami,
+  createTask,
+  listTasks,
+  getTask,
+  updateTask,
+  addComment,
+  completeTask,
+  listOrgs,
+};

package/src/config.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const Conf = require("conf");
+
+const config = new Conf({
+  projectName: "1medium-cli",
+  schema: {
+    token: {
+      type: "string",
+      default: "",
+    },
+    apiUrl: {
+      type: "string",
+      default: "https://1medium.ai/api",
+    },
+    orgId: {
+      type: "string",
+      default: "",
+    },
+    orgName: {
+      type: "string",
+      default: "",
+    },
+  },
+});
+
+// Allow environment variable override
+if (process.env.ONEMEDIUM_TOKEN) {
+  config.set("token", process.env.ONEMEDIUM_TOKEN);
+}
+
+if (process.env.ONEMEDIUM_API_URL) {
+  config.set("apiUrl", process.env.ONEMEDIUM_API_URL);
+}
+
+if (process.env.ONEMEDIUM_ORG_ID) {
+  config.set("orgId", process.env.ONEMEDIUM_ORG_ID);
+}
+
+module.exports = config;

package/src/index.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+"use strict";
+
+const { Command } = require("commander");
+const chalk = require("chalk");
+const { version } = require("../package.json");
+const config = require("./config");
+const api = require("./api");
+
+const program = new Command();
+
+program
+  .name("1m")
+  .description("1Medium CLI for AI coding agent integration")
+  .version(version);
+
+// ============================================================================
+// Auth Commands
+// ============================================================================
+
+program
+  .command("login")
+  .description("Configure your 1Medium API token")
+  .option("-t, --token <token>", "API token (1m_pat_xxx)")
+  .option("-u, --url <url>", "API URL (default: https://1medium.ai/api)")
+  .action(async (options) => {
+    try {
+      if (options.token) {
+        if (!options.token.startsWith("1m_pat_")) {
+          console.error(chalk.red("Error: Token must start with 1m_pat_"));
+          process.exit(1);
+        }
+        config.set("token", options.token);
+        console.log(chalk.green("Token saved successfully!"));
+      } else {
+        // Interactive mode - prompt for token
+        const readline = require("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        rl.question("Enter your 1Medium API token (1m_pat_xxx): ", (token) => {
+          rl.close();
+          if (!token.startsWith("1m_pat_")) {
+            console.error(chalk.red("Error: Token must start with 1m_pat_"));
+            process.exit(1);
+          }
+          config.set("token", token);
+          console.log(chalk.green("Token saved successfully!"));
+        });
+      }
+
+      if (options.url) {
+        config.set("apiUrl", options.url);
+        console.log(chalk.green(`API URL set to: ${options.url}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("logout")
+  .description("Remove stored credentials")
+  .action(() => {
+    config.clear();
+    console.log(chalk.green("Credentials removed."));
+  });
+
+program
+  .command("whoami")
+  .description("Display current token info and rate limits")
+  .action(async () => {
+    try {
+      const data = await api.whoami();
+      console.log(chalk.bold("\nToken Info:"));
+      console.log(`  Name:    ${data.token.name}`);
+      console.log(`  Prefix:  ${data.token.prefix}`);
+      console.log(`  Scopes:  ${data.token.scopes.join(", ")}`);
+      if (data.token.repo_allowlist) {
+        console.log(`  Repos:   ${data.token.repo_allowlist.join(", ")}`);
+      }
+      console.log(chalk.bold("\nRate Limits:"));
+      console.log(`  Requests/min:  ${data.rate_limits.requests_per_minute}`);
+      console.log(`  Creates/hour:  ${data.rate_limits.creates_per_hour}`);
+      console.log(
+        `  Limited:       ${data.rate_limits.request_limited ? chalk.red("Yes") : chalk.green("No")}`
+      );
+      console.log(chalk.bold("\nUser:"));
+      console.log(`  Email:    ${data.user.email}`);
+      console.log(`  Username: ${data.user.username}`);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// Task Commands
+// ============================================================================
+
+const taskCmd = program.command("task").description("Manage tasks");
+
+taskCmd
+  .command("add")
+  .description("Create a new task")
+  .requiredOption("-t, --title <title>", "Task title (min 10 chars)")
+  .option("-b, --body <body>", "Task body (markdown)")
+  .option("-p, --priority <priority>", "Priority: P0, P1, P2, P3", "P2")
+  .option("-s, --status <status>", "Status: inbox, open, doing, blocked, done", "inbox")
+  .option("--tag <tags...>", "Tags to add")
+  .option("--repo <repo>", "Repository context (owner/repo)")
+  .option("--branch <branch>", "Branch context")
+  .option("--commit <commit>", "Commit SHA context")
+  .option("--file <files...>", "File paths context")
+  .option("--pr <url>", "PR URL context")
+  .option("--issue <url>", "Issue URL context")
+  .option("--estimate <minutes>", "Time estimate in minutes", parseInt)
+  .option("--due <date>", "Due date (ISO 8601)")
+  .option("--source <source>", "Source identifier", "cli")
+  .option("--no-dedupe", "Disable deduplication")
+  .option("-j, --json", "Output as JSON")
+  .action(async (options) => {
+    try {
+      const context = {};
+      if (options.repo) context.repo = options.repo;
+      if (options.branch) context.branch = options.branch;
+      if (options.commit) context.commit = options.commit;
+      if (options.file) context.files = options.file;
+      if (options.pr) context.pr_url = options.pr;
+      if (options.issue) context.issue_url = options.issue;
+
+      const payload = {
+        title: options.title,
+        body_md: options.body,
+        priority: options.priority,
+        status: options.status,
+        tags: options.tag || [],
+        context,
+        source: options.source,
+        estimate_minutes: options.estimate,
+        due_at: options.due,
+        dedupe: {
+          mode: options.dedupe === false ? "none" : "auto",
+        },
+      };
+
+      const data = await api.createTask(payload);
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        if (data.deduped) {
+          console.log(chalk.yellow("Similar task already exists (deduped):"));
+        } else {
+          console.log(chalk.green("Task created:"));
+        }
+        console.log(`  ID:       ${data.task.id}`);
+        console.log(`  Title:    ${data.task.title}`);
+        console.log(`  Status:   ${data.task.status}`);
+        console.log(`  Priority: ${data.task.priority}`);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      if (error.details) {
+        error.details.forEach((d) => console.error(chalk.red(`  - ${d}`)));
+      }
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command("list")
+  .description("List tasks")
+  .option("-s, --status <status>", "Filter by status")
+  .option("-p, --priority <priority>", "Filter by priority")
+  .option("--repo <repo>", "Filter by repository")
+  .option("--tag <tag>", "Filter by tag")
+  .option("--created-by <type>", "Filter by creator: all, agent, user", "all")
+  .option("-l, --limit <limit>", "Number of tasks to return", "20")
+  .option("-o, --offset <offset>", "Offset for pagination", "0")
+  .option("-j, --json", "Output as JSON")
+  .action(async (options) => {
+    try {
+      const params = {
+        status: options.status,
+        priority: options.priority,
+        repo: options.repo,
+        tag: options.tag,
+        created_by: options.createdBy,
+        limit: options.limit,
+        offset: options.offset,
+      };
+
+      const data = await api.listTasks(params);
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(chalk.bold(`\nTasks (${data.total} total):\n`));
+        if (data.tasks.length === 0) {
+          console.log("  No tasks found.");
+        } else {
+          for (const task of data.tasks) {
+            const priorityColor =
+              task.priority === "P0"
+                ? chalk.red
+                : task.priority === "P1"
+                  ? chalk.yellow
+                  : chalk.white;
+            const statusIcon =
+              task.status === "done"
+                ? chalk.green("[x]")
+                : task.status === "doing"
+                  ? chalk.blue("[>]")
+                  : task.status === "blocked"
+                    ? chalk.red("[!]")
+                    : "[ ]";
+
+            console.log(
+              `${statusIcon} ${priorityColor(task.priority)} ${task.title.substring(0, 60)}${task.title.length > 60 ? "..." : ""}`
+            );
+            console.log(chalk.gray(`    ID: ${task.id}`));
+          }
+        }
+        console.log("");
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command("get <id>")
+  .description("Get task details")
+  .option("-j, --json", "Output as JSON")
+  .action(async (id, options) => {
+    try {
+      const data = await api.getTask(id);
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        const task = data.task;
+        console.log(chalk.bold(`\n${task.title}\n`));
+        console.log(`  ID:       ${task.id}`);
+        console.log(`  Status:   ${task.status}`);
+        console.log(`  Priority: ${task.priority}`);
+        if (task.tags?.length) {
+          console.log(`  Tags:     ${task.tags.join(", ")}`);
+        }
+        if (task.due_at) {
+          console.log(`  Due:      ${task.due_at}`);
+        }
+        if (task.estimate_minutes) {
+          console.log(`  Estimate: ${task.estimate_minutes} minutes`);
+        }
+        if (task.context) {
+          console.log(chalk.bold("\n  Context:"));
+          if (task.context.repo) console.log(`    Repo:   ${task.context.repo}`);
+          if (task.context.branch) console.log(`    Branch: ${task.context.branch}`);
+          if (task.context.commit) console.log(`    Commit: ${task.context.commit}`);
+          if (task.context.pr_url) console.log(`    PR:     ${task.context.pr_url}`);
+        }
+        if (task.body_md) {
+          console.log(chalk.bold("\n  Description:"));
+          console.log(`    ${task.body_md.replace(/\n/g, "\n    ")}`);
+        }
+        if (task.comments?.length) {
+          console.log(chalk.bold("\n  Comments:"));
+          for (const comment of task.comments) {
+            console.log(chalk.gray(`    [${comment.created_at}]`));
+            console.log(`    ${comment.content.replace(/\n/g, "\n    ")}`);
+            console.log("");
+          }
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command("update <id>")
+  .description("Update a task")
+  .option("-t, --title <title>", "New title")
+  .option("-b, --body <body>", "New body (markdown)")
+  .option("-p, --priority <priority>", "New priority: P0, P1, P2, P3")
+  .option("-s, --status <status>", "New status")
+  .option("--add-tag <tags...>", "Tags to add")
+  .option("--remove-tag <tags...>", "Tags to remove")
+  .option("--due <date>", "Due date (ISO 8601)")
+  .option("--estimate <minutes>", "Time estimate in minutes", parseInt)
+  .option("-j, --json", "Output as JSON")
+  .action(async (id, options) => {
+    try {
+      const payload = {};
+      if (options.title) payload.title = options.title;
+      if (options.body) payload.body_md = options.body;
+      if (options.priority) payload.priority = options.priority;
+      if (options.status) payload.status = options.status;
+      if (options.addTag) payload.tags_add = options.addTag;
+      if (options.removeTag) payload.tags_remove = options.removeTag;
+      if (options.due) payload.due_at = options.due;
+      if (options.estimate) payload.estimate_minutes = options.estimate;
+
+      const data = await api.updateTask(id, payload);
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(chalk.green("Task updated:"));
+        console.log(`  ID:       ${data.task.id}`);
+        console.log(`  Title:    ${data.task.title}`);
+        console.log(`  Status:   ${data.task.status}`);
+        console.log(`  Priority: ${data.task.priority}`);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command("comment <id>")
+  .description("Add a comment to a task")
+  .requiredOption("-m, --message <message>", "Comment message (markdown)")
+  .option("-j, --json", "Output as JSON")
+  .action(async (id, options) => {
+    try {
+      const data = await api.addComment(id, { comment_md: options.message });
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(chalk.green("Comment added:"));
+        console.log(`  ID: ${data.comment.id}`);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command("done <id>")
+  .description("Mark a task as complete")
+  .option("-m, --message <message>", "Completion summary (markdown)")
+  .option("-j, --json", "Output as JSON")
+  .action(async (id, options) => {
+    try {
+      const payload = {};
+      if (options.message) payload.summary_md = options.message;
+
+      const data = await api.completeTask(id, payload);
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(chalk.green("Task completed!"));
+        console.log(`  ID:    ${data.task.id}`);
+        console.log(`  Title: ${data.task.title}`);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// Org Commands
+// ============================================================================
+
+program
+  .command("orgs")
+  .description("List your organizations")
+  .option("-j, --json", "Output as JSON")
+  .action(async (options) => {
+    try {
+      const data = await api.listOrgs();
+      const currentOrgId = config.get("orgId");
+
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(chalk.bold("\nOrganizations:\n"));
+        for (const org of data.orgs) {
+          const current = org.id === currentOrgId ? chalk.green(" (current)") : "";
+          const personal = org.is_personal ? chalk.gray(" [personal]") : "";
+          console.log(`  ${org.name}${personal}${current}`);
+          console.log(chalk.gray(`    ID: ${org.id}`));
+        }
+        console.log("");
+        if (!currentOrgId) {
+          console.log(chalk.yellow("No default org set. Use: 1m config set org <org-id>"));
+          console.log("");
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// Config Commands
+// ============================================================================
+
+const configCmd = program.command("config").description("Manage configuration");
+
+configCmd
+  .command("show")
+  .description("Show current configuration")
+  .action(() => {
+    const token = config.get("token");
+    const apiUrl = config.get("apiUrl");
+    const orgId = config.get("orgId");
+    const orgName = config.get("orgName");
+
+    console.log(chalk.bold("\nConfiguration:\n"));
+    console.log(`  API URL: ${apiUrl || "https://1medium.ai/api (default)"}`);
+    console.log(`  Token:   ${token ? token.substring(0, 12) + "..." : chalk.yellow("Not set")}`);
+    console.log(`  Org:     ${orgName || chalk.yellow("Not set")}${orgId ? chalk.gray(` (${orgId})`) : ""}`);
+    console.log(`  Config:  ${config.path}`);
+    console.log("");
+  });
+
+configCmd
+  .command("set")
+  .description("Set a configuration value")
+  .argument("<key>", "Configuration key (org, url)")
+  .argument("<value>", "Configuration value")
+  .action(async (key, value) => {
+    try {
+      switch (key) {
+        case "org":
+          // Validate org exists and user has access
+          const data = await api.listOrgs();
+          const org = data.orgs.find((o) => o.id === value || o.name.toLowerCase() === value.toLowerCase());
+          if (!org) {
+            console.error(chalk.red(`Error: Organization not found: ${value}`));
+            console.log("\nAvailable organizations:");
+            for (const o of data.orgs) {
+              console.log(`  ${o.name} (${o.id})`);
+            }
+            process.exit(1);
+          }
+          config.set("orgId", org.id);
+          config.set("orgName", org.name);
+          console.log(chalk.green(`Default org set to: ${org.name}`));
+          break;
+        case "url":
+          config.set("apiUrl", value);
+          console.log(chalk.green(`API URL set to: ${value}`));
+          break;
+        default:
+          console.error(chalk.red(`Unknown config key: ${key}`));
+          console.log("Available keys: org, url");
+          process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Default action for `1m config` (no subcommand) - show config
+configCmd.action(() => {
+  const token = config.get("token");
+  const apiUrl = config.get("apiUrl");
+  const orgId = config.get("orgId");
+  const orgName = config.get("orgName");
+
+  console.log(chalk.bold("\nConfiguration:\n"));
+  console.log(`  API URL: ${apiUrl || "https://1medium.ai/api (default)"}`);
+  console.log(`  Token:   ${token ? token.substring(0, 12) + "..." : chalk.yellow("Not set")}`);
+  console.log(`  Org:     ${orgName || chalk.yellow("Not set")}${orgId ? chalk.gray(` (${orgId})`) : ""}`);
+  console.log(`  Config:  ${config.path}`);
+  console.log("");
+});
+
+// Parse and execute
+program.parse();

package/src/mcp-server.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+"use strict";
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require("@modelcontextprotocol/sdk/types.js");
+const api = require("./api");
+const config = require("./config");
+
+const server = new Server(
+  {
+    name: "1medium",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Define available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "task_create",
+        description: "Create a new task in 1Medium. Use this to track work items, todos, or any actionable items.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: {
+              type: "string",
+              description: "The task title/summary",
+            },
+            body: {
+              type: "string",
+              description: "Optional detailed description in markdown",
+            },
+            priority: {
+              type: "string",
+              enum: ["P1", "P2", "P3", "P4"],
+              description: "Task priority (P1=urgent, P4=low)",
+            },
+            source: {
+              type: "string",
+              description: "Source identifier (e.g., 'claude-code', 'github')",
+            },
+            context: {
+              type: "object",
+              description: "Additional context like repo, branch, file paths",
+            },
+          },
+          required: ["title"],
+        },
+      },
+      {
+        name: "task_list",
+        description: "List tasks from 1Medium. Returns open tasks by default.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: ["open", "completed", "all"],
+              description: "Filter by task status",
+            },
+            priority: {
+              type: "string",
+              enum: ["P1", "P2", "P3", "P4"],
+              description: "Filter by priority",
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of tasks to return",
+            },
+          },
+        },
+      },
+      {
+        name: "task_get",
+        description: "Get details of a specific task by ID",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Task ID (UUID or uid like A1, A2)",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "task_update",
+        description: "Update an existing task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Task ID to update",
+            },
+            title: {
+              type: "string",
+              description: "New title",
+            },
+            body: {
+              type: "string",
+              description: "New description",
+            },
+            priority: {
+              type: "string",
+              enum: ["P1", "P2", "P3", "P4"],
+              description: "New priority",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "task_complete",
+        description: "Mark a task as completed",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Task ID to complete",
+            },
+            summary: {
+              type: "string",
+              description: "Optional completion summary",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "task_comment",
+        description: "Add a comment/update to a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Task ID to comment on",
+            },
+            message: {
+              type: "string",
+              description: "Comment text (supports markdown)",
+            },
+          },
+          required: ["id", "message"],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  // Check if configured
+  const token = config.get("token");
+  if (!token) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Error: 1Medium CLI not configured. Run '1m login' to set up authentication.",
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    let result;
+
+    switch (name) {
+      case "task_create": {
+        const payload = {
+          title: args.title,
+          body_md: args.body,
+          priority: args.priority || "P2",
+          source: args.source || "claude-code",
+          context: args.context || {},
+        };
+        result = await api.createTask(payload);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Task created:\n  ID: ${result.task.id}\n  Title: ${result.task.title}\n  Priority: ${result.task.priority}`,
+            },
+          ],
+        };
+      }
+
+      case "task_list": {
+        const params = {};
+        if (args.status) params.status = args.status;
+        if (args.priority) params.priority = args.priority;
+        if (args.limit) params.limit = args.limit;
+
+        result = await api.listTasks(params);
+        const tasks = result.tasks || [];
+
+        if (tasks.length === 0) {
+          return {
+            content: [{ type: "text", text: "No tasks found." }],
+          };
+        }
+
+        const taskList = tasks
+          .map((t) => {
+            const check = t.completedAt ? "[x]" : "[ ]";
+            return `${check} ${t.priority} ${t.title}\n    ID: ${t.id}`;
+          })
+          .join("\n\n");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Tasks (${result.total} total):\n\n${taskList}`,
+            },
+          ],
+        };
+      }
+
+      case "task_get": {
+        result = await api.getTask(args.id);
+        const t = result.task;
+        const status = t.completedAt ? "completed" : "open";
+
+        let text = `${t.title}\n\n  ID: ${t.id}\n  Status: ${status}\n  Priority: ${t.priority}`;
+
+        if (t.body_md) {
+          text += `\n\n  Description:\n${t.body_md}`;
+        }
+
+        if (t.comments && t.comments.length > 0) {
+          text += `\n\n  Comments:`;
+          for (const c of t.comments) {
+            text += `\n    [${c.createdAt}] ${c.body_md}`;
+          }
+        }
+
+        return {
+          content: [{ type: "text", text }],
+        };
+      }
+
+      case "task_update": {
+        const payload = {};
+        if (args.title) payload.title = args.title;
+        if (args.body) payload.body_md = args.body;
+        if (args.priority) payload.priority = args.priority;
+
+        result = await api.updateTask(args.id, payload);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Task updated:\n  ID: ${result.task.id}\n  Title: ${result.task.title}\n  Priority: ${result.task.priority}`,
+            },
+          ],
+        };
+      }
+
+      case "task_complete": {
+        const payload = {};
+        if (args.summary) payload.completion_summary = args.summary;
+
+        result = await api.completeTask(args.id, payload);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Task completed!\n  ID: ${result.task.id}\n  Title: ${result.task.title}`,
+            },
+          ],
+        };
+      }
+
+      case "task_comment": {
+        result = await api.addComment(args.id, { body_md: args.message });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Comment added to task ${args.id}`,
+            },
+          ],
+        };
+      }
+
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true,
+        };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error.message}${error.details ? `\nDetails: ${JSON.stringify(error.details)}` : ""}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("1Medium MCP server running");
+}
+
+main().catch(console.error);