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

package/LICENSE

@@ -1,21 +1,202 @@
-MIT License
-
-Copyright (c) 2026 cloudvoyant
-
-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.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+Difflab CLI
+Copyright 2026 cloudvoyant

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,271 @@ 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 metadata = { ...envelope };
+      delete metadata[this.itemsKey];
+      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}`, { cause: error });
+      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 +27693,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 +27789,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 +27819,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 +27843,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 +27854,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 +27883,8 @@ function codexServerStatus(content) {
 var codexAdapter;
 var init_codex = __esm(() => {
   init_adapter();
+  init_errors4();
+  init_osx();
   codexAdapter = {
     id: "codex",
     async setupMcpConfig(context = {}) {
@@ -27707,14 +27894,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 +27941,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 +30013,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.2.0";
 await createProgram(console.log, version2).parseAsync(process.argv);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@difflab/difflab-cli",
-  "version": "0.1.0-rc.6",
+  "version": "0.2.0",
   "private": false,
   "description": "A minimal Bun CLI starter built with Commander",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/difflab-io/difflab.git",
@@ -20,7 +20,8 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "publishConfig": {
     "access": "public",