@difflab/difflab-cli 0.1.0-rc.6 → 0.1.0

package/README.md

@@ -5,10 +5,10 @@ A Bun command-line application with a local Difflab MCP server.
 ## Run
 
 ```bash
-bunx @difflab/difflab-cli Premise
+bunx @difflab/difflab-cli
 ```
 
-## MCP todo tools
+## MCP setup
 
 After installing the CLI so `difflab-cli` is on your PATH, register it with the MCP clients you use:
 
@@ -19,18 +19,7 @@ difflab-cli mcp setup --client cursor --client codex
 
 Clients are selected explicitly. Supported names: `pi`, `cursor`, `codex`, `claude-code`, and `claude-desktop`. Pi uses the shared `~/.config/mcp/mcp.json` file (through the Pi MCP adapter), Cursor uses `~/.cursor/mcp.json`, Codex uses its CLI, Claude Code uses its CLI with user scope, and Claude Desktop uses its platform-specific user config. These clients do **not** all read one common file. Setup adds Difflab only when absent, leaves other servers in place, and refuses to replace a conflicting `difflab` entry. Codex and Claude Code must have their CLIs installed if selected. Restart or reload the selected client after setup.
 
-`mcp setup` does **not** create a todo file. Use the `todo_init` MCP tool to create a list. MCP clients launch `npx -y @difflab/difflab-cli mcp serve` over stdio, so no daemon or port is needed. Bun must be on the client's PATH.
-
-Each todo call requires **`cwd` (an absolute path to an existing directory)** and **`path` (a relative path to a JSON todo file inside that directory)**. They are supplied per call, not in the MCP server configuration. For example, with `cwd` set to `/home/alex`:
-
-```text
-todo_init({"cwd":"/home/alex","path":"todos.json"})
-todo_add({"cwd":"/home/alex","path":"todos.json","text":"Review PR"})
-```
-
-`todo_list`, `todo_complete`, and `todo_remove` also require both fields; the latter two require a task `id` returned by `todo_list` or `todo_add`. Call `todo_init` before other operations on a new file. Parent traversal outside `cwd`, absolute `path` values, and symlinked paths are rejected. Keep personal todo files outside the repository or add their paths to `.gitignore`. Concurrent writes to the same file are not yet coordinated.
-
-Agents in this repo can load `skills/difflab-todo/SKILL.md` for usage instructions.
+MCP clients launch `npx -y @difflab/difflab-cli mcp serve` over stdio, so no daemon or port is needed. Bun must be on the client's PATH.
 
 ## Develop
 

package/dist/index.js

@@ -27336,9 +27336,6 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/tools.ts
-function result(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value) }] };
-}
 function defineTool(name, config, handler) {
   return {
     name,
@@ -27347,26 +27344,36 @@ function defineTool(name, config, handler) {
       inputSchema: config.inputSchema,
       ...config.annotations ? { annotations: config.annotations } : {}
     },
-    callback: async (input) => {
+    callback: async (untrustedInput) => {
       try {
-        return result(await handler(config.inputSchema.parse(input)));
+        return serializeToolResult(await handler(config.inputSchema.parse(untrustedInput)));
       } catch (error) {
         return {
-          ...result({ error: error instanceof Error ? error.message : String(error) }),
+          ...serializeToolResult({ error: error instanceof Error ? error.message : String(error) }),
           isError: true
         };
       }
     }
   };
 }
+function serializeToolResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
 
-// src/todos/path.ts
-import { lstat, realpath, stat } from "fs/promises";
-import { isAbsolute, join, relative, resolve, sep } from "path";
-function isFileError(error, code) {
+// src/extensions/osx.ts
+import { homedir } from "os";
+function resolveHomeDirectory(home) {
+  return home ?? homedir();
+}
+function hasErrorCode(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
-async function resolveTodoPath(cwd, path) {
+var init_osx = () => {};
+
+// src/extensions/pathx.ts
+import { lstat, realpath, stat } from "fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+async function resolvePath(cwd, path) {
   if (!isAbsolute(cwd))
     throw new Error("cwd must be an absolute path to an existing directory");
   if (!path.trim() || isAbsolute(path))
@@ -27384,126 +27391,270 @@ async function resolveTodoPath(cwd, path) {
     current = join(current, segment);
     try {
       if ((await lstat(current)).isSymbolicLink()) {
-        throw new Error(`Symlink paths are not allowed for todo files: ${current}`);
+        throw new Error(`Symlink paths are not allowed for files: ${current}`);
       }
     } catch (error) {
-      if (isFileError(error, "ENOENT"))
+      if (hasErrorCode(error, "ENOENT"))
         break;
       throw error;
     }
   }
   return file;
 }
-var init_path = () => {};
+var init_pathx = __esm(() => {
+  init_osx();
+});
 
-// src/todos/store.ts
+// src/stores/json-file-store.ts
 import { randomUUID } from "crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
 import { dirname, resolve as resolve2 } from "path";
-function isFileError2(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
 
-class TodoStore {
+class JsonFileStore {
+  schema;
   file;
-  constructor(file) {
+  itemsKey;
+  metadata;
+  envelopeMetadata = {};
+  constructor(file, schema, options) {
+    this.schema = schema;
     this.file = resolve2(file);
+    this.itemsKey = options?.itemsKey;
+    this.metadata = options?.metadata ?? {};
   }
-  async initialize() {
+  async read(id) {
+    const item = (await this.list()).find((candidate) => candidate.id === id);
+    if (!item)
+      throw new JsonFileStoreMissingItemError(`Item does not exist: ${id}`);
+    return item;
+  }
+  async list() {
+    const envelope = await this.load();
+    const raw = this.itemsKey ? envelope[this.itemsKey] : envelope;
+    if (!Array.isArray(raw)) {
+      throw new JsonFileStoreValidationError(`Invalid JSON store at ${this.file}`);
+    }
+    const items = raw.map((item) => this.parse(item));
+    this.validateUniqueIds(items);
+    return items;
+  }
+  async write(item) {
+    const value = this.parse(item);
+    const items = await this.list();
+    const index = items.findIndex((candidate) => candidate.id === value.id);
+    if (index === -1)
+      items.push(value);
+    else
+      items[index] = value;
+    await this.persist(items);
+  }
+  async replace(items) {
+    const validated = items.map((item) => this.parse(item));
+    this.validateUniqueIds(validated);
+    await this.persist(validated);
+  }
+  async update(id, mutation) {
+    const items = await this.list();
+    const index = items.findIndex((item) => item.id === id);
+    if (index === -1)
+      throw new JsonFileStoreMissingItemError(`Item does not exist: ${id}`);
+    const current = items[index];
+    const updated = this.parse(mutation(current) ?? current);
+    items[index] = updated;
+    this.validateUniqueIds(items);
+    await this.persist(items);
+    return updated;
+  }
+  async initialize(items = []) {
     await mkdir(dirname(this.file), { recursive: true });
-    const list = { version: 1, tasks: [] };
+    const validated = items.map((item) => this.parse(item));
+    this.validateUniqueIds(validated);
     try {
-      await writeFile(this.file, `${JSON.stringify(list, null, 2)}
-`, { flag: "wx", mode: 384 });
-      return { created: true, list };
+      await writeFile(this.file, this.serialize(validated), { flag: "wx", mode: 384 });
+      return true;
+    } catch (error) {
+      if (error.code === "EEXIST")
+        return false;
+      throw new JsonFileStoreWriteError(`Could not write JSON file: ${this.file}`, { cause: error });
+    }
+  }
+  async load() {
+    let content;
+    try {
+      content = await readFile(this.file, "utf8");
     } catch (error) {
-      if (!isFileError2(error, "EEXIST"))
+      const ErrorType = error.code === "ENOENT" ? JsonFileStoreNotFoundError : JsonFileStoreReadError;
+      throw new ErrorType(`Could not read JSON file: ${this.file}`, { cause: error });
+    }
+    try {
+      const parsed = JSON.parse(content);
+      if (!this.itemsKey)
+        return parsed;
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Envelope must be an object");
+      const envelope = parsed;
+      for (const [key, value] of Object.entries(this.metadata)) {
+        if (envelope[key] !== value)
+          throw new Error(`Invalid metadata: ${key}`);
+      }
+      const { [this.itemsKey]: _, ...metadata } = envelope;
+      this.envelopeMetadata = metadata;
+      return envelope;
+    } catch (error) {
+      if (error instanceof JsonFileStoreValidationError)
         throw error;
-      return { created: false, list: await this.read() };
+      throw new JsonFileStoreValidationError(`Invalid JSON store at ${this.file}`, { cause: error });
     }
   }
-  async list() {
-    return this.read();
+  parse(value) {
+    try {
+      return this.schema.parse(value);
+    } catch (error) {
+      throw new JsonFileStoreValidationError(`Invalid item for ${this.file}`, { cause: error });
+    }
   }
-  async add(text) {
-    const value = string2().trim().min(1).parse(text);
-    const list = await this.read();
-    const task = { id: randomUUID(), text: value, done: false };
-    list.tasks.push(task);
-    await this.write(list);
-    return task;
+  validateUniqueIds(items) {
+    if (new Set(items.map((item) => item.id)).size !== items.length) {
+      throw new JsonFileStoreValidationError(`Invalid item IDs for ${this.file}`);
+    }
   }
-  async complete(id) {
-    const list = await this.read();
-    const task = list.tasks.find((item) => item.id === id);
-    if (!task)
-      throw new Error(`Unknown task ID: ${id}`);
-    task.done = true;
-    await this.write(list);
-    return task;
+  serialize(items) {
+    const payload = this.itemsKey ? { ...this.envelopeMetadata, ...this.metadata, [this.itemsKey]: items } : items;
+    return `${JSON.stringify(payload, null, 2)}
+`;
   }
-  async remove(id) {
-    const list = await this.read();
-    const index = list.tasks.findIndex((item) => item.id === id);
-    if (index === -1)
-      throw new Error(`Unknown task ID: ${id}`);
-    const [task] = list.tasks.splice(index, 1);
-    await this.write(list);
-    return task;
+  async persist(items) {
+    const temp = `${this.file}.${randomUUID()}.tmp`;
+    try {
+      await writeFile(temp, this.serialize(items), { mode: 384 });
+      await rename(temp, this.file);
+    } catch (error) {
+      throw new JsonFileStoreWriteError(`Could not write JSON file: ${this.file}`, { cause: error });
+    } finally {
+      await rm(temp, { force: true });
+    }
   }
-  async read() {
-    let content;
+}
+var JsonFileStoreError, JsonFileStoreReadError, JsonFileStoreNotFoundError, JsonFileStoreWriteError, JsonFileStoreValidationError, JsonFileStoreMissingItemError;
+var init_json_file_store = __esm(() => {
+  JsonFileStoreError = class JsonFileStoreError extends Error {
+    constructor(message, options) {
+      super(message, options);
+      this.name = new.target.name;
+    }
+  };
+  JsonFileStoreReadError = class JsonFileStoreReadError extends JsonFileStoreError {
+  };
+  JsonFileStoreNotFoundError = class JsonFileStoreNotFoundError extends JsonFileStoreReadError {
+  };
+  JsonFileStoreWriteError = class JsonFileStoreWriteError extends JsonFileStoreError {
+  };
+  JsonFileStoreValidationError = class JsonFileStoreValidationError extends JsonFileStoreError {
+  };
+  JsonFileStoreMissingItemError = class JsonFileStoreMissingItemError extends JsonFileStoreReadError {
+  };
+});
+
+// src/todos/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+
+class TodoStore {
+  file;
+  tasks;
+  constructor(file) {
+    this.file = resolve3(file);
+    this.tasks = new JsonFileStore(this.file, taskSchema, {
+      itemsKey: "tasks",
+      metadata: { version: 1 }
+    });
+  }
+  async initialize() {
+    await mkdir2(dirname2(this.file), { recursive: true });
+    const created = await this.tasks.initialize();
+    return { created, list: created ? { version: 1, tasks: [] } : await this.list() };
+  }
+  async list() {
     try {
-      content = await readFile(this.file, "utf8");
+      return { version: 1, tasks: await this.tasks.list() };
     } catch (error) {
-      if (isFileError2(error, "ENOENT")) {
+      if (error instanceof JsonFileStoreNotFoundError) {
         throw new Error(`Todo list does not exist: ${this.file}. Call todo_init first.`, {
           cause: error
         });
       }
+      if (error instanceof JsonFileStoreValidationError) {
+        throw new Error(`Invalid todo list at ${this.file}`, { cause: error });
+      }
       throw error;
     }
+  }
+  async add(text) {
+    const task = { id: randomUUID2(), text: string2().trim().min(1).parse(text), done: false };
     try {
-      const list = listSchema.parse(JSON.parse(content));
-      if (new Set(list.tasks.map((task) => task.id)).size !== list.tasks.length) {
-        throw new Error("duplicate task IDs");
-      }
-      return list;
+      await this.tasks.write(task);
+      return task;
     } catch (error) {
-      throw new Error(`Invalid todo list at ${this.file}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      this.rethrowDomainError(error);
     }
   }
-  async write(list) {
-    const temp = `${this.file}.${randomUUID()}.tmp`;
+  async complete(id) {
     try {
-      await writeFile(temp, `${JSON.stringify(list, null, 2)}
-`, { flag: "wx", mode: 384 });
-      await rename(temp, this.file);
-    } finally {
-      await rm(temp, { force: true });
+      return await this.tasks.update(id, (task) => {
+        task.done = true;
+      });
+    } catch (error) {
+      if (error instanceof JsonFileStoreMissingItemError)
+        throw new Error(`Unknown task ID: ${id}`);
+      this.rethrowDomainError(error);
     }
   }
+  async remove(id) {
+    let list;
+    try {
+      list = await this.tasks.list();
+    } catch (error) {
+      this.rethrowDomainError(error);
+    }
+    const task = list.find((item) => item.id === id);
+    if (!task)
+      throw new Error(`Unknown task ID: ${id}`);
+    try {
+      await this.tasks.replace(list.filter((item) => item.id !== id));
+      return task;
+    } catch (error) {
+      this.rethrowDomainError(error);
+    }
+  }
+  rethrowDomainError(error) {
+    if (error instanceof JsonFileStoreNotFoundError) {
+      throw new Error(`Todo list does not exist: ${this.file}. Call todo_init first.`, {
+        cause: error
+      });
+    }
+    if (error instanceof JsonFileStoreValidationError) {
+      throw new Error(`Invalid todo list at ${this.file}`, { cause: error });
+    }
+    throw error;
+  }
 }
-var taskSchema, listSchema;
+var taskSchema;
 var init_store = __esm(() => {
   init_zod();
-  taskSchema = strictObject({
-    id: uuid2(),
-    text: string2().min(1),
-    done: boolean2()
-  });
-  listSchema = strictObject({ version: literal(1), tasks: array(taskSchema) });
+  init_json_file_store();
+  taskSchema = strictObject({ id: uuid2(), text: string2().min(1), done: boolean2() });
 });
 
 // src/todos/tools.ts
 import { isAbsolute as isAbsolute2 } from "path";
 async function store(cwd, path) {
-  return new TodoStore(await resolveTodoPath(cwd, path));
+  return new TodoStore(await resolvePath(cwd, path));
 }
 var cwd, path2, id, fileInput, todoTools;
 var init_tools = __esm(() => {
   init_zod();
-  init_path();
+  init_pathx();
   init_store();
   cwd = string2().refine(isAbsolute2, "cwd must be an absolute path").describe("Absolute path to an existing base directory, such as the repository root. Never use the server process cwd implicitly.");
   path2 = string2().min(1).refine((value) => value.trim().length > 0 && !isAbsolute2(value), "path must be relative to cwd").describe("Relative path to the JSON todo file inside cwd, such as todos.json or .local/todos.json. No escaping cwd or symlinks.");
@@ -27541,98 +27692,95 @@ var init_tools = __esm(() => {
   ];
 });
 
-// src/mcp.ts
-function createDifflabServer(version = "0.1.0") {
+// src/mcp/server.ts
+async function serveMcp(version = "0.1.0") {
   const server = new McpServer({ name: "difflab", version });
   for (const tool of todoTools) {
     server.registerTool(tool.name, tool.config, tool.callback);
   }
-  return server;
-}
-async function serveMcp(version) {
-  await createDifflabServer(version).connect(new StdioServerTransport);
+  await server.connect(new StdioServerTransport);
 }
-var init_mcp2 = __esm(() => {
+var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
   init_tools();
 });
 
-// src/agents/adapter.ts
+// src/errors.ts
+var DifflabError, ConfigurationError, CommandExecutionError;
+var init_errors4 = __esm(() => {
+  DifflabError = class DifflabError extends Error {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "DifflabError";
+    }
+  };
+  ConfigurationError = class ConfigurationError extends DifflabError {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "ConfigurationError";
+    }
+  };
+  CommandExecutionError = class CommandExecutionError extends DifflabError {
+    constructor(command, message, options) {
+      super(`Could not configure ${command}: ${message}`, options);
+      this.name = "CommandExecutionError";
+    }
+  };
+});
+
+// src/extensions/processx.ts
 import { execFileSync } from "child_process";
-import { homedir } from "os";
-function setupHome(context) {
-  return context.home ?? homedir();
-}
 function runCommand(command, args, cwd) {
   try {
     execFileSync(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
   } catch (error) {
-    throw new Error(`Could not configure ${command}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    throw new CommandExecutionError(command, error instanceof Error ? error.message : String(error), { cause: error });
   }
 }
-function isFileError3(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
+var init_processx = __esm(() => {
+  init_errors4();
+});
+
+// src/agents/adapter.ts
+function setupHome(context) {
+  return resolveHomeDirectory(context.home);
 }
 var mcpServer;
 var init_adapter = __esm(() => {
+  init_osx();
+  init_processx();
   mcpServer = {
     command: "npx",
     args: ["-y", "@difflab/difflab-cli", "mcp", "serve"]
   };
 });
 
-// src/agents/json-config.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { lstat as lstat2, mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+// src/extensions/fsx.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { lstat as lstat2, mkdir as mkdir3, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
 function isObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-async function readJsonConfig(file) {
+async function readJsonFile(file) {
   try {
-    if ((await lstat2(file)).isSymbolicLink()) {
-      throw new Error(`MCP config at ${file} is a symlink; refusing to replace it`);
-    }
-    const content = await readFile2(file, "utf8");
-    try {
-      const parsed = JSON.parse(content);
-      if (!isObject2(parsed))
-        throw new Error("root must be a JSON object");
-      return parsed;
-    } catch (error) {
-      throw new Error(`Invalid MCP config at ${file}; not modified: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
+    if ((await lstat2(file)).isSymbolicLink())
+      throw new Error(`JSON file at ${file} is a symlink`);
+    const parsed = JSON.parse(await readFile2(file, "utf8"));
+    if (!isObject2(parsed))
+      throw new Error("root must be a JSON object");
+    return parsed;
   } catch (error) {
-    if (isFileError3(error, "ENOENT"))
+    if (hasErrorCode(error, "ENOENT"))
       return {};
     throw error;
   }
 }
-function serverStatus(config, file) {
-  if (config.mcpServers !== undefined && !isObject2(config.mcpServers)) {
-    throw new Error(`Invalid MCP config at ${file}; mcpServers must be an object`);
-  }
-  if (!isObject2(config.mcpServers) || !Object.hasOwn(config.mcpServers, "difflab")) {
-    return "missing";
-  }
-  const entry = config.mcpServers.difflab;
-  return isObject2(entry) && entry.command === mcpServer.command && Array.isArray(entry.args) && entry.args.length === mcpServer.args.length && entry.args.every((arg, index) => arg === mcpServer.args[index]) ? "matching" : "conflicting";
-}
-async function addJsonServer(file) {
-  const config = await readJsonConfig(file);
-  const status = serverStatus(config, file);
-  if (status === "matching")
-    return { file, status: "existing" };
-  if (status === "conflicting") {
-    throw new Error(`MCP server "difflab" already exists in ${file} with a different configuration; not modified`);
-  }
-  const updated = {
-    ...config,
-    mcpServers: { ...isObject2(config.mcpServers) ? config.mcpServers : {}, difflab: mcpServer }
-  };
-  await mkdir2(dirname2(file), { recursive: true });
-  const temp = `${file}.${randomUUID2()}.tmp`;
+async function patchJsonToFile(file, patch) {
+  const updated = patch(await readJsonFile(file));
+  await mkdir3(dirname3(file), { recursive: true });
+  const temp = `${file}.${randomUUID3()}.tmp`;
   try {
     await writeFile2(temp, `${JSON.stringify(updated, null, 2)}
 `, { flag: "wx", mode: 384 });
@@ -27640,7 +27788,27 @@ async function addJsonServer(file) {
   } finally {
     await rm2(temp, { force: true });
   }
-  return { file, status: "added" };
+}
+var init_fsx = __esm(() => {
+  init_osx();
+});
+
+// src/mcp/json-config.ts
+async function readJsonConfig(file) {
+  try {
+    return await readJsonFile(file);
+  } catch (error) {
+    throw new ConfigurationError(`Invalid MCP config at ${file}; not modified: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function serverStatus(config, file) {
+  if (config.mcpServers !== undefined && !isObject2(config.mcpServers)) {
+    throw new ConfigurationError(`Invalid MCP config at ${file}; mcpServers must be an object`);
+  }
+  if (!isObject2(config.mcpServers) || !Object.hasOwn(config.mcpServers, "difflab"))
+    return "missing";
+  const entry = config.mcpServers.difflab;
+  return isObject2(entry) && entry.command === mcpServer.command && Array.isArray(entry.args) && entry.args.length === mcpServer.args.length && entry.args.every((arg, index) => arg === mcpServer.args[index]) ? "matching" : "conflicting";
 }
 function jsonAgentAdapter(id, configPath) {
   return {
@@ -27650,8 +27818,23 @@ function jsonAgentAdapter(id, configPath) {
     }
   };
 }
+async function addJsonServer(file) {
+  const config = await readJsonConfig(file);
+  const status = serverStatus(config, file);
+  if (status === "matching")
+    return { file, status: "existing" };
+  if (status === "conflicting")
+    throw new ConfigurationError(`MCP server "difflab" already exists in ${file} with a different configuration; not modified`);
+  await patchJsonToFile(file, (current) => ({
+    ...current,
+    mcpServers: { ...isObject2(current.mcpServers) ? current.mcpServers : {}, difflab: mcpServer }
+  }));
+  return { file, status: "added" };
+}
 var init_json_config = __esm(() => {
   init_adapter();
+  init_errors4();
+  init_fsx();
 });
 
 // src/agents/claude-code.ts
@@ -27659,6 +27842,7 @@ import { join as join2 } from "path";
 var claudeCodeAdapter;
 var init_claude_code = __esm(() => {
   init_adapter();
+  init_errors4();
   init_json_config();
   claudeCodeAdapter = {
     id: "claude-code",
@@ -27669,7 +27853,7 @@ var init_claude_code = __esm(() => {
       if (status === "matching")
         return { file, status: "existing" };
       if (status === "conflicting") {
-        throw new Error(`MCP server "difflab" already exists in ${file} with a different configuration; not modified`);
+        throw new ConfigurationError(`MCP server "difflab" already exists in ${file} with a different configuration; not modified`);
       }
       const run = context.run ?? runCommand;
       run("claude", ["mcp", "add", "--scope", "user", "difflab", "--", mcpServer.command, ...mcpServer.args], home);
@@ -27698,6 +27882,8 @@ function codexServerStatus(content) {
 var codexAdapter;
 var init_codex = __esm(() => {
   init_adapter();
+  init_errors4();
+  init_osx();
   codexAdapter = {
     id: "codex",
     async setupMcpConfig(context = {}) {
@@ -27707,14 +27893,14 @@ var init_codex = __esm(() => {
       try {
         content = await readFile3(file, "utf8");
       } catch (error) {
-        if (!isFileError3(error, "ENOENT"))
+        if (!hasErrorCode(error, "ENOENT"))
           throw error;
       }
       const status = codexServerStatus(content);
       if (status === "matching")
         return { file, status: "existing" };
       if (status === "conflicting") {
-        throw new Error(`Codex already has a different difflab entry in ${file}; not modified`);
+        throw new ConfigurationError(`Codex already has a different difflab entry in ${file}; not modified`);
       }
       const run = context.run ?? runCommand;
       run("codex", ["mcp", "add", "difflab", "--", mcpServer.command, ...mcpServer.args], home);
@@ -27754,6 +27940,33 @@ var init_agents = __esm(() => {
   agentNames = Object.keys(agentAdapters);
 });
 
+// src/mcp/setup.ts
+async function setupMcpClients(clients, write) {
+  if (clients.length === 0) {
+    throw new Error(`Select at least one client with --client (${agentNames.join(", ")})`);
+  }
+  const adapters = [...new Set(clients)].map((name) => {
+    const adapter = agentAdapter(name);
+    if (!adapter)
+      throw new Error(`Unknown MCP client: ${name}. Choose ${agentNames.join(", ")}`);
+    return adapter;
+  });
+  for (const adapter of adapters) {
+    const { file, status } = await adapter.setupMcpConfig();
+    write(`${status === "added" ? "Added" : "Already configured"} ${adapter.id}: ${file}`);
+  }
+  write("Restart or reload the selected client to use the Difflab MCP tools.");
+}
+var init_setup = __esm(() => {
+  init_agents();
+});
+
+// src/mcp/index.ts
+var init_mcp2 = __esm(() => {
+  init_server3();
+  init_setup();
+});
+
 // ../../node_modules/commander/lib/error.js
 class CommanderError extends Error {
   constructor(exitCode, code, message) {
@@ -29799,36 +30012,21 @@ function useColor() {
 var program = new Command;
 
 // src/cli.ts
-function greeting(name) {
-  return `Hello, ${name}!`;
-}
 function createProgram(write = console.log, version = "0.1.0") {
-  const program = new Command().name("difflab-cli").description("Difflab CLI and local MCP server").version(version).argument("[name]", "name to greet", "world").action((name) => write(greeting(name)));
+  const program = new Command().name("difflab-cli").description("Difflab CLI and local MCP server").version(version);
+  program.action(() => program.outputHelp());
   const mcp = program.command("mcp").description("Difflab MCP server commands");
   mcp.command("serve").description("Serve Difflab tools over MCP stdio").action(async () => {
     await Promise.resolve().then(() => init_mcp2());
     await serveMcp(version);
   });
   mcp.command("setup").description("Register the installed Difflab MCP server in selected user-level clients").option("--client <name>", "pi, cursor, codex, claude-code, or claude-desktop (repeatable)", (name, selected) => [...selected, name], []).action(async ({ client }) => {
-    await Promise.resolve().then(() => init_agents());
-    if (client.length === 0) {
-      throw new Error(`Select at least one client with --client (${agentNames.join(", ")})`);
-    }
-    const adapters = [...new Set(client)].map((name) => {
-      const adapter = agentAdapter(name);
-      if (!adapter)
-        throw new Error(`Unknown MCP client: ${name}. Choose ${agentNames.join(", ")}`);
-      return adapter;
-    });
-    for (const adapter of adapters) {
-      const { file, status } = await adapter.setupMcpConfig();
-      write(`${status === "added" ? "Added" : "Already configured"} ${adapter.id}: ${file}`);
-    }
-    write("Restart or reload the selected client to use the Difflab MCP tools.");
+    await Promise.resolve().then(() => init_mcp2());
+    await setupMcpClients(client, write);
   });
   return program;
 }
 
 // src/index.ts
-var version2 = "0.1.0-rc.6";
+var version2 = "0.1.0";
 await createProgram(console.log, version2).parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@difflab/difflab-cli",
-  "version": "0.1.0-rc.6",
+  "version": "0.1.0",
   "private": false,
   "description": "A minimal Bun CLI starter built with Commander",
   "license": "MIT",