claude-do-it 0.0.0-stage → 0.1.1

package/bin/do-it.js

@@ -0,0 +1,1208 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/cli/src/main.ts
+import { BunRuntime, BunServices } from "@effect/platform-bun";
+
+// packages/client/src/paths.ts
+import { Config, Effect, Option, Path } from "effect";
+var defaultHome = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const configured = yield* Config.option(Config.String("DO_IT_HOME"));
+  if (Option.isSome(configured))
+    return configured.value;
+  return path.join(yield* Config.String("HOME"), ".do-it");
+}).pipe(Effect.orDie);
+function paths(home) {
+  return Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const root = path.resolve(home ?? (yield* defaultHome));
+    const lock = path.join(root, "daemon.lock");
+    return {
+      home: root,
+      daemon: path.join(root, "daemon.json"),
+      token: path.join(root, "token"),
+      lock,
+      lockPid: path.join(lock, "pid"),
+      log: path.join(root, "daemon.log"),
+      versions: path.join(root, "versions.json")
+    };
+  });
+}
+// packages/client/src/info.ts
+import { Data, Effect as Effect2, FileSystem } from "effect";
+class DaemonUnavailable extends Data.TaggedError("DaemonUnavailable") {
+}
+function readDaemonInfo(home) {
+  return Effect2.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const p = yield* paths(home);
+    if ((yield* fs.stat(p.daemon)).size > 4096n || (yield* fs.stat(p.token)).size > 128n)
+      return null;
+    const text = yield* fs.readFileString(p.daemon);
+    const token = (yield* fs.readFileString(p.token)).trim();
+    const record = yield* Effect2.try(() => JSON.parse(text));
+    if (!record || !Number.isSafeInteger(record.pid) || record.pid <= 0 || !Number.isInteger(record.port) || record.port < 1 || record.port > 65535 || typeof record.appVersion !== "string" || !Number.isFinite(record.startedAt) || !/^[a-f0-9]{64}$/.test(token))
+      return null;
+    const port = record.port;
+    return {
+      home: p.home,
+      pid: record.pid,
+      port,
+      appVersion: record.appVersion,
+      startedAt: record.startedAt,
+      token,
+      baseUrl: `http://127.0.0.1:${port}`
+    };
+  }).pipe(Effect2.catch(() => Effect2.succeed(null)));
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var probeHealth = (info) => Effect2.tryPromise({
+  try: async (signal) => {
+    const response = await fetch(`${info.baseUrl}/health`, { signal: AbortSignal.any([signal, AbortSignal.timeout(500)]) });
+    if (!response.ok)
+      return null;
+    const body = await response.json();
+    return body.ok === true && body.pid === info.pid && typeof body.appVersion === "string" ? body : null;
+  },
+  catch: () => new DaemonUnavailable({ message: "The daemon did not answer its health check" })
+}).pipe(Effect2.catch(() => Effect2.succeed(null)));
+// packages/protocol/src/schema.ts
+import { Schema } from "effect";
+var MAX_TEXT_LENGTH = 2 * 1024 * 1024;
+var MAX_TASK_TEXT_LENGTH = 4096;
+var Text = Schema.String.pipe(Schema.check(Schema.isMaxLength(MAX_TEXT_LENGTH)));
+var TaskText = Schema.String.pipe(Schema.check(Schema.isMaxLength(MAX_TASK_TEXT_LENGTH)));
+var Path3 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.length > 0 && value.startsWith("/") ? undefined : "an absolute, non-empty path is required"), Schema.isMaxLength(MAX_TEXT_LENGTH)));
+var Version = Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)));
+var User = Schema.TaggedStruct("User", {});
+var Agent = Schema.TaggedStruct("Agent", {
+  name: Schema.String.pipe(Schema.check(Schema.isBetweenLength(1, 64), Schema.isPattern(/^[A-Za-z0-9._-]+$/)))
+});
+var File = Schema.TaggedStruct("File", {});
+var Author = Schema.Union([User, Agent, File]);
+var TaskState = Schema.Literals(["open", "done", "cancelled"]);
+var Todo = Schema.Struct({
+  number: Schema.Number,
+  line: Schema.Number,
+  state: TaskState,
+  text: TaskText,
+  indent: Schema.Number,
+  section: Schema.NullOr(Text)
+});
+var TodoChange = Schema.Struct({
+  kind: Schema.Literals([
+    "added",
+    "removed",
+    "checked",
+    "unchecked",
+    "cancelled",
+    "uncancelled",
+    "edited"
+  ]),
+  number: Schema.Number,
+  text: TaskText,
+  line: Schema.Number,
+  oldLine: Schema.Number
+});
+var Section = Schema.Struct({
+  id: Text,
+  title: Text,
+  level: Schema.Literals([1, 2, 3]),
+  line: Schema.Number
+});
+var Others = Schema.Struct({
+  since: Version,
+  diff: Schema.NullOr(Text)
+});
+var Replace = Schema.TaggedStruct("Replace", {
+  old: Text,
+  new: Text
+});
+var Append = Schema.TaggedStruct("Append", {
+  text: Text
+});
+var TodoAdd = Schema.TaggedStruct("TodoAdd", {
+  text: TaskText
+});
+var TodoSet = Schema.TaggedStruct("TodoSet", {
+  target: Schema.Union([Schema.Number, Text]),
+  state: TaskState
+});
+var TodoStart = Schema.TaggedStruct("TodoStart", {
+  target: Schema.Union([Schema.Number, Text])
+});
+var EditOp = Schema.Union([Replace, Append, TodoAdd, TodoSet, TodoStart]);
+var SectionId = Schema.optional(Text);
+var StatusPayload = Schema.Struct({});
+var StatusDocument = Schema.Struct({
+  path: Path3,
+  version: Version,
+  watchers: Schema.Number
+});
+var StatusSuccess = Schema.Struct({
+  pid: Schema.Number,
+  appVersion: Text,
+  port: Schema.Number,
+  startedAt: Schema.Number,
+  documents: Schema.Array(StatusDocument)
+});
+var StopPayload = Schema.Struct({});
+var StopSuccess = Schema.Struct({});
+var OpenPayload = Schema.Struct({
+  path: Path3,
+  create: Schema.Boolean
+});
+var OpenSuccess = Schema.Struct({
+  path: Path3,
+  version: Version,
+  url: Text,
+  created: Schema.Boolean
+});
+var ReadPayload = Schema.Struct({
+  path: Path3,
+  section: SectionId
+});
+var ReadSuccess = Schema.Struct({
+  version: Version,
+  text: Text
+});
+var SectionsPayload = Schema.Struct({ path: Path3 });
+var SectionsSuccess = Schema.Struct({
+  version: Version,
+  sections: Schema.Array(Section)
+});
+var TodosPayload = Schema.Struct({
+  path: Path3,
+  section: SectionId
+});
+var TodosSuccess = Schema.Struct({
+  version: Version,
+  todos: Schema.Array(Todo)
+});
+var EditPayload = Schema.Struct({
+  path: Path3,
+  author: Author,
+  version: Version,
+  section: SectionId,
+  op: EditOp
+});
+var EditSuccess = Schema.Struct({
+  version: Version,
+  changed: Schema.Boolean,
+  section: Schema.NullOr(Text),
+  others: Schema.NullOr(Others)
+});
+var SyncPayload = Schema.Struct({
+  path: Path3,
+  base: Version,
+  text: Text
+});
+var SyncSuccess = Schema.Struct({
+  version: Version,
+  text: Text
+});
+var DiffPayload = Schema.Struct({
+  path: Path3,
+  since: Version,
+  wait: Schema.Number.pipe(Schema.check(Schema.isBetween({ minimum: 0, maximum: 600 })))
+});
+var DiffSuccess = Schema.Struct({
+  from: Version,
+  to: Version,
+  by: Schema.Array(Author),
+  diff: Schema.NullOr(Text),
+  todos: Schema.Array(TodoChange)
+});
+var WatchPayload = Schema.Struct({
+  path: Path3,
+  since: Schema.optional(Version),
+  section: SectionId,
+  text: Schema.Boolean
+});
+var Watching = Schema.TaggedStruct("Watching", {
+  version: Version,
+  text: Schema.optionalKey(Text)
+});
+var Change = Schema.TaggedStruct("Change", {
+  from: Version,
+  to: Version,
+  by: Schema.Array(Author),
+  diff: Schema.NullOr(Text),
+  todos: Schema.Array(TodoChange),
+  text: Schema.optionalKey(Text)
+});
+var Resync = Schema.TaggedStruct("Resync", {
+  version: Version,
+  text: Schema.optionalKey(Text)
+});
+var Deleted = Schema.TaggedStruct("Deleted", {});
+var WatchEvent = Schema.Union([Watching, Change, Resync, Deleted]);
+// packages/protocol/src/errors.ts
+import { Schema as Schema2 } from "effect";
+class VersionMismatch extends Schema2.TaggedError()("VersionMismatch", {
+  latest: Version,
+  since: Version,
+  diff: Schema2.NullOr(Text),
+  forgotten: Schema2.Boolean
+}) {
+}
+var RefusedCode = Schema2.Literals(["not-found", "ambiguous", "too-large", "invalid"]);
+
+class Refused extends Schema2.TaggedError()("Refused", {
+  code: RefusedCode,
+  message: Text
+}) {
+}
+
+class Forgotten extends Schema2.TaggedError()("Forgotten", {
+  latest: Version
+}) {
+}
+
+class NothingYet extends Schema2.TaggedError()("NothingYet", {}) {
+}
+
+class DocumentGone extends Schema2.TaggedError()("DocumentGone", {
+  path: Path3
+}) {
+}
+
+class Unauthorized extends Schema2.TaggedError()("Unauthorized", {}) {
+}
+var RpcFailure = Schema2.Union([
+  VersionMismatch,
+  Refused,
+  Forgotten,
+  NothingYet,
+  DocumentGone,
+  Unauthorized
+]);
+// packages/protocol/src/rpcs.ts
+import { Rpc, RpcGroup } from "effect/rpc";
+var statusRpc = Rpc.make("status", {
+  payload: StatusPayload,
+  success: StatusSuccess,
+  error: RpcFailure
+});
+var stopRpc = Rpc.make("stop", {
+  payload: StopPayload,
+  success: StopSuccess,
+  error: RpcFailure
+});
+var openRpc = Rpc.make("open", {
+  payload: OpenPayload,
+  success: OpenSuccess,
+  error: RpcFailure
+});
+var readRpc = Rpc.make("read", {
+  payload: ReadPayload,
+  success: ReadSuccess,
+  error: RpcFailure
+});
+var sectionsRpc = Rpc.make("sections", {
+  payload: SectionsPayload,
+  success: SectionsSuccess,
+  error: RpcFailure
+});
+var todosRpc = Rpc.make("todos", {
+  payload: TodosPayload,
+  success: TodosSuccess,
+  error: RpcFailure
+});
+var editRpc = Rpc.make("edit", {
+  payload: EditPayload,
+  success: EditSuccess,
+  error: RpcFailure
+});
+var syncRpc = Rpc.make("sync", {
+  payload: SyncPayload,
+  success: SyncSuccess,
+  error: RpcFailure
+});
+var diffRpc = Rpc.make("diff", {
+  payload: DiffPayload,
+  success: DiffSuccess,
+  error: RpcFailure
+});
+var watchRpc = Rpc.make("watch", {
+  payload: WatchPayload,
+  success: WatchEvent,
+  error: RpcFailure,
+  stream: true
+});
+var DoItRpcs = RpcGroup.make(statusRpc, stopRpc, openRpc, readRpc, sectionsRpc, todosRpc, editRpc, syncRpc, diffRpc, watchRpc);
+// packages/protocol/src/format.ts
+var describeAuthor = (author) => {
+  switch (author._tag) {
+    case "User":
+      return "the user";
+    case "Agent":
+      return author.name;
+    case "File":
+      return "file";
+  }
+};
+var formatTodoChange = (change) => `${change.kind} ${change.number}. ${change.text}`;
+var formatVersionHeader = (from, to, by) => {
+  const version = from === to || to === from + 1 ? `Version ${to}` : `Versions ${from + 1}-${to}`;
+  return by.length === 0 ? version : `${version} by ${by.map(describeAuthor).join(", ")}`;
+};
+var exitCodeFor = (error) => {
+  switch (error._tag) {
+    case "Refused":
+      return error.code === "invalid" ? 2 : 1;
+    case "NothingYet":
+      return 4;
+    case "DocumentGone":
+      return 9;
+    case "Unauthorized":
+      return 3;
+    case "VersionMismatch":
+    case "Forgotten":
+      return 1;
+  }
+};
+// packages/protocol/src/index.ts
+var APP_VERSION = "0.1.1";
+
+// packages/client/src/lifecycle.ts
+import { Effect as Effect4, FileSystem as FileSystem2, Option as Option2, Path as Path4, Semaphore } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+
+// packages/client/src/rpc.ts
+import { Context, Effect as Effect3, Layer } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { RpcClient as Rpc2, RpcSerialization } from "effect/rpc";
+
+class RpcClient extends Context.Service()("@do-it/client/RpcClient") {
+}
+function RpcClientLive(info) {
+  const http = Layer.effect(HttpClient.HttpClient, Effect3.map(HttpClient.HttpClient, HttpClient.filterStatusOk)).pipe(Layer.provide(FetchHttpClient.layer));
+  const protocol = Rpc2.layerProtocolHttp({
+    url: `${info.baseUrl}/rpc`,
+    transformClient: (client) => HttpClient.mapRequest(client, (request) => request.pipe(HttpClientRequest.setUrl(`${info.baseUrl}/rpc`), HttpClientRequest.setHeader("Authorization", `Bearer ${info.token}`)))
+  }).pipe(Layer.provide([http, RpcSerialization.layerNdjson]));
+  return Layer.effect(RpcClient, Rpc2.make(DoItRpcs)).pipe(Layer.provide(protocol));
+}
+function withClient(info, f) {
+  return Effect3.flatMap(RpcClient, f).pipe(Effect3.provide(RpcClientLive(info)));
+}
+
+// packages/client/src/lifecycle.ts
+var unavailable = (cause) => cause instanceof DaemonUnavailable ? cause : new DaemonUnavailable({ message: cause instanceof Error ? cause.message : String(cause) });
+var attempt = (f) => Effect4.try({ try: f, catch: unavailable });
+function unless(reason, fallback) {
+  return (effect) => Effect4.catch(effect, (error) => error.reason._tag === reason ? Effect4.succeed(fallback) : Effect4.fail(error));
+}
+var lockTurn = Semaphore.makeUnsafe(1);
+var daemonEntry = new URL("./daemon.js", import.meta.url);
+var daemonScript = 'exec "$0" "$1" >>"$2" 2>&1';
+var stopDaemon = Effect4.fn("stopDaemon")(function* (home) {
+  const info = yield* readDaemonInfo(home);
+  if (!info || !alive(info.pid))
+    return false;
+  const stopped = yield* withClient(info, (client) => client.stop({})).pipe(Effect4.timeout("500 millis"), Effect4.map(() => true), Effect4.catch(() => Effect4.succeed(false)));
+  if (!stopped) {
+    const signalled = yield* attempt(() => {
+      if (info.pid !== process.pid && alive(info.pid))
+        process.kill(info.pid, "SIGTERM");
+    }).pipe(Effect4.result);
+    if (signalled._tag === "Failure")
+      return false;
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!(yield* probeHealth(info)))
+      return true;
+    yield* Effect4.sleep("50 millis");
+  }
+  return false;
+});
+var ensureDaemon = Effect4.fn("ensureDaemon")(function* (options = {}) {
+  const fs = yield* FileSystem2.FileSystem;
+  const path = yield* Path4.Path;
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const p = yield* paths(options.home ?? options.env?.DO_IT_HOME);
+  const compatible = Effect4.gen(function* () {
+    const info = yield* readDaemonInfo(p.home);
+    if (!info || !alive(info.pid))
+      return null;
+    const health = yield* probeHealth(info);
+    return health && health.appVersion === APP_VERSION && info.appVersion === APP_VERSION ? info : null;
+  });
+  const existing = yield* compatible;
+  if (existing)
+    return existing;
+  if (options.spawn === false)
+    return yield* Effect4.fail(new DaemonUnavailable({ message: "No compatible daemon is running" }));
+  yield* fs.makeDirectory(p.home, { recursive: true, mode: 448 }).pipe(Effect4.andThen(fs.chmod(p.home, 448)), Effect4.mapError(unavailable));
+  const lockOnce = Effect4.gen(function* () {
+    const created = yield* fs.makeDirectory(p.lock, { mode: 448 }).pipe(Effect4.as(true), unless("AlreadyExists", false));
+    if (created) {
+      yield* fs.writeFileString(p.lockPid, String(process.pid), { mode: 384 });
+      return Option2.getOrNull((yield* fs.stat(p.lock)).ino);
+    }
+    const stat = yield* fs.stat(p.lock).pipe(unless("NotFound", undefined));
+    if (!stat)
+      return;
+    const text = yield* fs.readFileString(p.lockPid).pipe(unless("NotFound", undefined));
+    const pid = text === undefined ? undefined : Number(text);
+    const modified = Option2.match(stat.mtime, { onNone: () => 0, onSome: (date) => date.getTime() });
+    const abandoned = pid !== undefined && Number.isSafeInteger(pid) && pid > 0 ? !alive(pid) : Date.now() - modified > 1e4;
+    if (abandoned)
+      yield* fs.remove(p.lock, { recursive: true, force: true });
+    return;
+  }).pipe(lockTurn.withPermit, Effect4.mapError(unavailable));
+  let inode;
+  const lockDeadline = Date.now() + 12000;
+  while (inode === undefined) {
+    inode = yield* lockOnce;
+    if (inode !== undefined)
+      break;
+    if (Date.now() > lockDeadline)
+      return yield* Effect4.fail(new DaemonUnavailable({ message: "Timed out waiting for the daemon startup lock" }));
+    yield* Effect4.sleep("50 millis");
+  }
+  const held = inode;
+  const release = fs.stat(p.lock).pipe(Effect4.flatMap((stat) => Option2.getOrNull(stat.ino) === held ? fs.remove(p.lock, { recursive: true, force: true }) : Effect4.void), lockTurn.withPermit, Effect4.ignore);
+  const start = Effect4.gen(function* () {
+    const found = yield* compatible;
+    if (found)
+      return found;
+    const old = yield* readDaemonInfo(p.home);
+    if (old && alive(old.pid) && !(yield* stopDaemon(p.home))) {
+      return yield* Effect4.fail(new DaemonUnavailable({ message: "The previous daemon could not be stopped" }));
+    }
+    const size = yield* fs.stat(p.log).pipe(Effect4.map((stat) => stat.size), unless("NotFound", 0n), Effect4.mapError(unavailable));
+    if (size >= 1024n * 1024n)
+      yield* fs.rename(p.log, `${p.log}.old`).pipe(Effect4.mapError(unavailable));
+    yield* fs.writeFileString(p.log, "", { flag: "a", mode: 384 }).pipe(Effect4.mapError(unavailable));
+    const main = yield* path.fromFileUrl(daemonEntry).pipe(Effect4.mapError(unavailable));
+    const env = { ...options.env, DO_IT_HOME: p.home };
+    if (options.port !== undefined)
+      env.DO_IT_PORT = String(options.port);
+    const command = ChildProcess.make("/bin/sh", ["-c", daemonScript, process.execPath, main, p.log], {
+      detached: true,
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      env,
+      extendEnv: true
+    });
+    const child = yield* spawner.spawn(command).pipe(Effect4.mapError(unavailable));
+    yield* child.unref.pipe(Effect4.mapError(unavailable));
+    const wait = Effect4.gen(function* () {
+      const deadline = Date.now() + 5000;
+      while (Date.now() < deadline) {
+        const info = yield* compatible;
+        if (info)
+          return info;
+        if (!(yield* child.isRunning.pipe(Effect4.mapError(unavailable))))
+          break;
+        yield* Effect4.sleep("50 millis");
+      }
+      return yield* Effect4.fail(new DaemonUnavailable({ message: `The daemon did not start, see ${p.log}` }));
+    });
+    return yield* wait.pipe(Effect4.onError(() => child.kill({ forceKillAfter: "1 second" }).pipe(Effect4.ignore)));
+  });
+  return yield* Effect4.scoped(start).pipe(Effect4.ensuring(release));
+});
+// packages/cli/src/main.ts
+import { Cause, Duration, Effect as Effect10, Exit, FiberHandle, Stdio as Stdio2, Stream as Stream2 } from "effect";
+import { CliConfig as CliConfig2, CliOutput as CliOutput2, Command as Command2 } from "effect/cli";
+
+// packages/cli/src/browser.ts
+import { Config as Config2, Effect as Effect5, Option as Option3 } from "effect";
+import { ChildProcess as ChildProcess2, ChildProcessSpawner as ChildProcessSpawner2 } from "effect/process";
+var openBrowser = (url) => Effect5.gen(function* () {
+  const configured = Option3.getOrUndefined(yield* Config2.option(Config2.String("DO_IT_BROWSER")));
+  if (configured?.toLowerCase() === "true")
+    return;
+  const command = configured || (process.platform === "darwin" ? "open" : "xdg-open");
+  const spawner = yield* ChildProcessSpawner2.ChildProcessSpawner;
+  const opener = ChildProcess2.make("/bin/sh", ["-c", `${command} "$1"`, "sh", url], {
+    detached: true,
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  yield* Effect5.scoped(Effect5.flatMap(spawner.spawn(opener), (child) => child.unref));
+}).pipe(Effect5.ignore);
+
+// packages/cli/src/output.ts
+import { Console } from "effect";
+function writeLine(text = "") {
+  return Console.log(text.endsWith(`
+`) ? text.slice(0, -1) : text);
+}
+function writeJson(value) {
+  return writeLine(JSON.stringify(value));
+}
+function diffText(header, diff) {
+  return diff ? `${header}
+${diff}` : header;
+}
+function editReply(result) {
+  if (!result.changed)
+    return { text: `Unchanged. Version: ${result.version}`, json: { kind: "unchanged", version: result.version, section: result.section, others: result.others, diff: result.others?.diff ?? null } };
+  if (result.section && result.others) {
+    const header = `Updated section "${result.section}". Version: ${result.version}. Other sections changed since ${result.others.since}:`;
+    return { text: diffText(header, result.others.diff), json: { kind: "updated-section", version: result.version, section: result.section, others: result.others, diff: result.others.diff } };
+  }
+  return { text: `Updated. Version: ${result.version}`, json: { kind: "updated", version: result.version, section: result.section, others: result.others, diff: result.others?.diff ?? null } };
+}
+function field(error, key) {
+  return typeof error === "object" && error !== null && key in error ? error[key] : undefined;
+}
+function mismatchReply(error, requested) {
+  const latest = typeof field(error, "latest") === "number" ? field(error, "latest") : requested;
+  const forgotten = field(error, "forgotten") === true || field(error, "_tag") === "Forgotten";
+  if (forgotten) {
+    const text = `Version mismatch, nothing changed. Latest version: ${latest}. Version ${requested} is no longer kept: run do-it read`;
+    return { text, json: { kind: "version-mismatch", latest, since: requested, diff: null, forgotten: true } };
+  }
+  const since = typeof field(error, "since") === "number" ? field(error, "since") : requested;
+  const diff = typeof field(error, "diff") === "string" ? field(error, "diff") : null;
+  const header = `Version mismatch, nothing changed. Latest version: ${latest}. Changes since ${since}:`;
+  return { text: diffText(header, diff), json: { kind: "version-mismatch", latest, since, diff, forgotten: false } };
+}
+function changeReply(change, todosOnly) {
+  return todosOnly ? change.todos.map(formatTodoChange).join(`
+`) : diffText(formatVersionHeader(change.from, change.to, change.by), change.diff);
+}
+function changeJson(change) {
+  return { event: "change", from: change.from, to: change.to, by: change.by, diff: change.diff, todos: change.todos };
+}
+function todosText(changes) {
+  return changes.map(formatTodoChange).join(`
+`);
+}
+function rpcErrorCode(error) {
+  const tag = field(error, "_tag");
+  return typeof tag === "string" ? tag : "RpcClientError";
+}
+function isRpcFailure(error) {
+  const tag = field(error, "_tag");
+  return typeof tag === "string" && ["VersionMismatch", "Refused", "Forgotten", "NothingYet", "DocumentGone", "Unauthorized"].includes(tag);
+}
+function rpcExitCode(error) {
+  return isRpcFailure(error) ? exitCodeFor(error) : 3;
+}
+function errorMessage(error) {
+  const errors = field(error, "errors");
+  if (Array.isArray(errors) && errors.length > 0)
+    return errors.map(errorMessage).join(`
+`);
+  const message = field(error, "message");
+  return typeof message === "string" ? message : String(error);
+}
+function errorTag(error) {
+  const tag = field(error, "_tag");
+  return typeof tag === "string" ? tag : undefined;
+}
+function errorFields(error) {
+  if (typeof error !== "object" || error === null)
+    return {};
+  return Object.fromEntries(Object.entries(error).filter(([key]) => key !== "_tag" && key !== "message" && key !== "code"));
+}
+
+// packages/cli/src/parser.ts
+import { Config as Config3, Effect as Effect7, Option as Option4, Path as Path5, Schema as Schema3 } from "effect";
+import { Argument, CliConfig, CliError, CliOutput, Command, Flag, GlobalFlag } from "effect/cli";
+var cliFormatter = {
+  ...CliOutput.defaultFormatter({ colors: false }),
+  formatVersion: (name, version) => `${name} ${version}`
+};
+var cliPresenter = CliOutput.layerPresenter({
+  present: (event) => event._tag === "Help" && event.reason === "Requested" || event._tag === "Version" ? CliOutput.defaultPresenter.present(event) : Effect7.void
+});
+var subcommands = new Set(["open", "read", "sections", "edit", "append", "todo", "diff", "watch", "status", "stop"]);
+var valueFlags = new Set(["--old", "--new", "--section", "--version", "--since", "--wait", "--settle", "--as"]);
+function normalizeArgv(input) {
+  if (input[0] === "--skill")
+    return normalizeArgv(["skill", "show", ...input.slice(1)]);
+  const result = [];
+  let options = true;
+  for (let index = 0;index < input.length; index += 1) {
+    const value = input[index];
+    if (options && value === "--") {
+      options = false;
+      result.push(value);
+      continue;
+    }
+    if (options && valueFlags.has(value) && index + 1 < input.length && input[index + 1] !== "--") {
+      result.push(`${value}=${input[index + 1]}`);
+      index += 1;
+      continue;
+    }
+    result.push(value);
+  }
+  return result;
+}
+function hasNonGlobalArgument(input, end) {
+  let skipAsValue = false;
+  for (const [index, value] of input.entries()) {
+    if (index >= end)
+      break;
+    if (skipAsValue) {
+      skipAsValue = false;
+      continue;
+    }
+    if (value === "--as") {
+      skipAsValue = true;
+      continue;
+    }
+    if (value === "--json" || value.startsWith("--as=") || value === "--help" || value === "-h")
+      continue;
+    if (value.startsWith("-"))
+      continue;
+    return true;
+  }
+  return false;
+}
+function cliConfigFor(input) {
+  const versionIndex = input.findIndex((value) => value === "--version" || value === "-v");
+  const rootVersion = versionIndex >= 0 && !hasNonGlobalArgument(input, versionIndex);
+  return CliConfig.make({ builtIns: rootVersion || !input.some((value) => subcommands.has(value)) ? GlobalFlag.BuiltIns : GlobalFlag.BuiltIns.filter((builtIn) => builtIn !== GlobalFlag.Version) });
+}
+var PositiveInt = Schema3.Int.pipe(Schema3.check(Schema3.isGreaterThan(0)));
+var Seconds = Schema3.Finite.pipe(Schema3.check(Schema3.isBetween({ minimum: 0, maximum: 600 })));
+var AgentName = Schema3.String.pipe(Schema3.check(Schema3.isBetweenLength(1, 64), Schema3.isPattern(/^[A-Za-z0-9._-]+$/)));
+var section = Flag.String("section").pipe(Flag.optional);
+var version = Flag.Int("version").pipe(Flag.withSchema(PositiveInt));
+var since = Flag.Int("since").pipe(Flag.withSchema(PositiveInt));
+var optionalSince = Flag.Int("since").pipe(Flag.withSchema(PositiveInt), Flag.optional);
+var wait = Flag.Finite("wait").pipe(Flag.withDefault(0), Flag.withSchema(Seconds));
+var settle = Flag.Finite("settle").pipe(Flag.withSchema(Seconds), Flag.optional);
+var optionValue = (value) => Option4.isSome(value) ? value.value : undefined;
+var pathValue = (value, optional = false) => {
+  const displayPath = optional ? value ?? "TODO.md" : value;
+  return { displayPath, path: displayPath };
+};
+var defaultAgent = Config3.option(Config3.String("DO_IT_AGENT")).pipe(Effect7.map((name) => Option4.getOrElse(name, () => "").trim() || "agent"), Effect7.orDie);
+var commonFlags = {
+  json: Flag.Boolean("json").pipe(Flag.withDefault(false)),
+  as: Flag.String("as").pipe(Flag.withDefault(defaultAgent), Flag.withSchema(AgentName))
+};
+function withCommon(root, input, run, make) {
+  return Effect7.gen(function* () {
+    const globals = yield* root;
+    const path = yield* Path5.Path;
+    const command = make(input, globals);
+    yield* run("path" in command ? { ...command, path: path.resolve(command.path) } : command);
+  });
+}
+function makeCli(run) {
+  const root = Command.make("do-it").pipe(Command.withDescription("Commands: open, read, sections, edit, append, todo add, todo start, todo check, todo uncheck, todo cancel, todo uncancel, todo list, diff, watch, status, stop, skill install, skill path, skill show (or --skill)"), Command.withSharedFlags(commonFlags));
+  const open = Command.make("open", {
+    path: Argument.String("path").pipe(Argument.optional),
+    noBrowser: Flag.Boolean("no-browser").pipe(Flag.withDefault(false))
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "open", options: common, ...pathValue(optionValue(config.path), true), noBrowser: config.noBrowser })));
+  const read = Command.make("read", {
+    path: Argument.String("path"),
+    section
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "read", options: common, ...pathValue(config.path), section: optionValue(config.section) })));
+  const sections = Command.make("sections", {
+    path: Argument.String("path")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "sections", options: common, ...pathValue(config.path) })));
+  const edit = Command.make("edit", {
+    path: Argument.String("path"),
+    version,
+    section,
+    old: Flag.String("old"),
+    next: Flag.String("new")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "edit", options: common, ...pathValue(config.path), version: config.version, section: optionValue(config.section), old: config.old, next: config.next })));
+  const append = Command.make("append", {
+    path: Argument.String("path"),
+    version,
+    section,
+    text: Argument.String("text")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "append", options: common, ...pathValue(config.path), version: config.version, section: optionValue(config.section), text: config.text })));
+  const todoAdd = Command.make("add", {
+    path: Argument.String("path"),
+    version,
+    section,
+    text: Argument.String("text")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "todo-add", options: common, ...pathValue(config.path), version: config.version, section: optionValue(config.section), text: config.text })));
+  const todoSet = (name, state) => Command.make(name, {
+    path: Argument.String("path"),
+    version,
+    section,
+    target: Argument.String("target")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "todo-set", options: common, ...pathValue(config.path), version: config.version, section: optionValue(config.section), target: config.target, state })));
+  const todoStart = Command.make("start", {
+    path: Argument.String("path"),
+    version,
+    section,
+    target: Argument.String("target")
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "todo-start", options: common, ...pathValue(config.path), version: config.version, section: optionValue(config.section), target: config.target })));
+  const todoList = Command.make("list", {
+    path: Argument.String("path"),
+    section
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "todo-list", options: common, ...pathValue(config.path), section: optionValue(config.section) })));
+  const todo = Command.make("todo").pipe(Command.withSubcommands([
+    todoAdd,
+    todoStart,
+    todoSet("check", "done"),
+    todoSet("uncheck", "open"),
+    todoSet("cancel", "cancelled"),
+    todoSet("uncancel", "open"),
+    todoList
+  ]));
+  const diff = Command.make("diff", {
+    path: Argument.String("path"),
+    since,
+    wait
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "diff", options: common, ...pathValue(config.path), since: config.since, wait: config.wait })));
+  const watch = Command.make("watch", {
+    path: Argument.String("path"),
+    optionalSince,
+    section,
+    todos: Flag.Boolean("todos").pipe(Flag.withDefault(false)),
+    settle,
+    quiet: Flag.Boolean("quiet").pipe(Flag.withDefault(false))
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "watch", options: common, ...pathValue(config.path), since: optionValue(config.optionalSince), section: optionValue(config.section), todos: config.todos, settle: optionValue(config.settle), quiet: config.quiet })));
+  const status = Command.make("status", {}, (input) => withCommon(root, input, run, (_config, common) => ({ kind: "status", options: common })));
+  const stop = Command.make("stop", {}, (input) => withCommon(root, input, run, (_config, common) => ({ kind: "stop", options: common })));
+  const skillInstall = Command.make("install", {
+    dir: Flag.String("dir").pipe(Flag.optional),
+    force: Flag.Boolean("force").pipe(Flag.withDefault(false))
+  }, (input) => withCommon(root, input, run, (config, common) => ({ kind: "skill-install", options: common, dir: optionValue(config.dir), force: config.force })));
+  const skillPath = Command.make("path", {}, (input) => withCommon(root, input, run, (_config, common) => ({ kind: "skill-path", options: common })));
+  const skillShow = Command.make("show", {}, (input) => withCommon(root, input, run, (_config, common) => ({ kind: "skill-show", options: common })));
+  const skill = Command.make("skill").pipe(Command.withDescription("Install the /do-it skill for Claude Code, print it, or print where this CLI keeps it"), Command.withSubcommands([skillInstall, skillPath, skillShow]));
+  return root.pipe(Command.withSubcommands([open, read, sections, edit, append, todo, diff, watch, status, stop, skill]));
+}
+
+// packages/cli/src/skill.ts
+import { Config as Config4, Effect as Effect8, FileSystem as FileSystem3, Option as Option5, Path as Path6 } from "effect";
+var skillRoot = new URL("../skill", import.meta.url);
+var MARKER = ".do-it-version";
+var skillSource = Effect8.gen(function* () {
+  const path = yield* Path6.Path;
+  return yield* path.fromFileUrl(skillRoot);
+}).pipe(Effect8.orDie);
+var readSkill = Effect8.gen(function* () {
+  const fs = yield* FileSystem3.FileSystem;
+  const path = yield* Path6.Path;
+  const file = path.join(yield* skillSource, "SKILL.md");
+  return { path: file, content: yield* fs.readFileString(file) };
+});
+var defaultSkillDir = Effect8.gen(function* () {
+  const path = yield* Path6.Path;
+  const configured = yield* Config4.option(Config4.String("CLAUDE_CONFIG_DIR"));
+  const base = Option5.isSome(configured) ? configured.value : path.join(yield* Config4.String("HOME"), ".claude");
+  return path.join(base, "skills", "do-it");
+}).pipe(Effect8.orDie);
+var installSkill = Effect8.fn("installSkill")(function* (dir, force) {
+  const fs = yield* FileSystem3.FileSystem;
+  const path = yield* Path6.Path;
+  const source = yield* skillSource;
+  const target = path.resolve(dir ?? (yield* defaultSkillDir));
+  const existing = yield* fs.lstat(target).pipe(Effect8.option);
+  if (Option5.isSome(existing)) {
+    const same = yield* fs.realPath(target).pipe(Effect8.map((real) => real === source), Effect8.orElseSucceed(() => false));
+    if (same)
+      return { kind: "linked", path: target };
+    const ours = existing.value.type === "Directory" && (yield* fs.exists(path.join(target, MARKER)));
+    if (!ours && !force)
+      return { kind: "occupied", path: target };
+    yield* fs.remove(target, { recursive: true });
+  }
+  yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+  yield* fs.copy(source, target);
+  yield* fs.writeFileString(path.join(target, MARKER), `${APP_VERSION}
+`);
+  return { kind: "installed", path: target, replaced: Option5.isSome(existing) };
+});
+
+// packages/cli/src/stdin.ts
+import { Effect as Effect9, Stdio, Stream } from "effect";
+var MAX_STDIN = 2 * 1024 * 1024;
+var readStdin = Effect9.gen(function* () {
+  const stdio = yield* Stdio.Stdio;
+  const chunks = [];
+  let total = 0;
+  yield* Stream.runForEach(stdio.stdin, (chunk) => {
+    total += chunk.byteLength;
+    if (total > MAX_STDIN)
+      return Effect9.fail(new Error("Standard input exceeds 2 MiB"));
+    chunks.push(chunk);
+    return Effect9.void;
+  });
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
+});
+function resolveText(text) {
+  return text === "-" ? readStdin : Effect9.succeed(text);
+}
+
+// packages/cli/src/main.ts
+function outputText(options, text, json) {
+  return options.json ? writeJson(json) : writeLine(text);
+}
+function sameAgent(by, name) {
+  return by.length > 0 && by.every((author) => author._tag === "Agent" && author.name === name);
+}
+function authorText(by) {
+  return by.map((author) => author._tag === "User" ? "the user" : author._tag === "File" ? "file" : author.name).join(", ");
+}
+function rpc(info, f) {
+  return withClient(info, f);
+}
+function openCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const result = yield* rpc(info, (client) => client.open({ path: command.path, create: true }));
+    if (!command.noBrowser)
+      yield* openBrowser(result.url);
+    const path = command.options.json ? result.path : command.displayPath;
+    yield* outputText(command.options, `Opened ${path} at version ${result.version}: ${result.url}`, { path, version: result.version, url: result.url, created: result.created });
+    return 0;
+  });
+}
+function readCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const result = yield* rpc(info, (client) => client.read({ path: command.path, ...command.section === undefined ? {} : { section: command.section } }));
+    if (command.options.json)
+      yield* writeJson({ version: result.version, text: result.text });
+    else
+      yield* writeLine(`Version: ${result.version}
+${result.text}`.replace(/\n$/, ""));
+    return 0;
+  });
+}
+function sectionsCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const result = yield* rpc(info, (client) => client.sections({ path: command.path }));
+    const text = [`Version: ${result.version}`, ...result.sections.map((section) => `${section.id}  (${section.level}) ${section.title}`)].join(`
+`);
+    yield* outputText(command.options, text, { version: result.version, sections: result.sections });
+    return 0;
+  });
+}
+function operation(command, text) {
+  if (command.kind === "edit")
+    return { _tag: "Replace", old: command.old, new: command.next };
+  if (command.kind === "append")
+    return { _tag: "Append", text: text ?? command.text };
+  if (command.kind === "todo-add")
+    return { _tag: "TodoAdd", text: text ?? command.text };
+  if (command.kind === "todo-start") {
+    const target = /^[+]?\d+$/.test(command.target.trim()) ? Number(command.target.trim()) : command.target;
+    return { _tag: "TodoStart", target };
+  }
+  const target = /^[+]?\d+$/.test(command.target.trim()) ? Number(command.target.trim()) : command.target;
+  return { _tag: "TodoSet", target, state: command.state };
+}
+function editCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const text = command.kind === "append" || command.kind === "todo-add" ? yield* resolveText(command.text) : undefined;
+    const result = yield* rpc(info, (client) => client.edit({
+      path: command.path,
+      author: { _tag: "Agent", name: command.options.as },
+      version: command.version,
+      ...command.section === undefined ? {} : { section: command.section },
+      op: operation(command, text)
+    }));
+    const reply = editReply(result);
+    yield* outputText(command.options, reply.text, reply.json);
+    return 0;
+  });
+}
+function todoListCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const result = yield* rpc(info, (client) => client.todos({ path: command.path, ...command.section === undefined ? {} : { section: command.section } }));
+    const lines = result.todos.map((todo) => `${todo.number}. [${todo.state === "done" ? "x" : todo.state === "cancelled" ? "-" : " "}] ${todo.text}`);
+    yield* outputText(command.options, [`Version: ${result.version}`, ...lines].join(`
+`), { version: result.version, todos: result.todos });
+    return 0;
+  });
+}
+function diffCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon();
+    const result = yield* rpc(info, (client) => client.diff({ path: command.path, since: command.since, wait: command.wait }));
+    const text = diffText(formatVersionHeader(result.from, result.to, result.by), result.diff);
+    yield* outputText(command.options, text, { from: result.from, to: result.to, by: result.by, diff: result.diff, todos: result.todos });
+    return 0;
+  });
+}
+function statusCommand(command) {
+  return Effect10.gen(function* () {
+    const info = yield* ensureDaemon({ spawn: false });
+    const result = yield* rpc(info, (client) => client.status({}));
+    const upSeconds = Math.floor(Math.max(0, Date.now() - result.startedAt) / 1000);
+    const minutes = Math.floor(upSeconds / 60);
+    if (command.options.json)
+      yield* writeJson({ pid: result.pid, port: result.port, startedAt: result.startedAt, appVersion: result.appVersion, documents: result.documents, upSeconds });
+    else
+      yield* writeLine(`Daemon pid ${result.pid} on 127.0.0.1:${result.port}, up ${minutes}m
+${result.documents.map((document) => `  ${document.path}  version ${document.version}  ${document.watchers} watchers`).join(`
+`)}`);
+    return 0;
+  });
+}
+function stopCommand(command) {
+  return Effect10.gen(function* () {
+    const stopped = yield* stopDaemon();
+    yield* outputText(command.options, stopped ? "Stopped" : "Not running", { stopped });
+    return 0;
+  });
+}
+function skillInstallCommand(command) {
+  return Effect10.gen(function* () {
+    const result = yield* installSkill(command.dir, command.force);
+    if (result.kind === "occupied") {
+      yield* outputText(command.options, `${result.path} already exists and was not installed by do-it. Pass --force to replace it.`, { error: { code: "Refused", message: "The skill directory already exists", path: result.path } });
+      return 1;
+    }
+    const text = result.kind === "linked" ? `${result.path} already links to this skill.` : `${result.replaced ? "Updated" : "Installed"} the do-it skill in ${result.path}. In Claude Code, run /do-it to start.`;
+    yield* outputText(command.options, text, { kind: result.kind, path: result.path });
+    return 0;
+  });
+}
+function skillPathCommand(command) {
+  return Effect10.gen(function* () {
+    const path = yield* skillSource;
+    yield* outputText(command.options, path, { path });
+    return 0;
+  });
+}
+function skillShowCommand(command) {
+  return Effect10.gen(function* () {
+    const skill = yield* readSkill;
+    yield* outputText(command.options, skill.content, skill);
+    return 0;
+  });
+}
+function initialWatchOutput(command, version) {
+  if (command.quiet)
+    return Effect10.void;
+  return outputText(command.options, `Watching ${command.displayPath} at version ${version}`, { event: "watching", version });
+}
+function restartOutput(command, version) {
+  return outputText(command.options, `Daemon restarted, now version ${version}`, { event: "restarted", version });
+}
+function resyncOutput(command, version) {
+  return outputText(command.options, `Missed changes, now at version ${version}: run do-it read`, { event: "resync", version });
+}
+function deletedOutput(command) {
+  return outputText(command.options, `Deleted ${command.displayPath}`, { event: "deleted" });
+}
+function watchCommand(command) {
+  return Effect10.scoped(Effect10.gen(function* () {
+    let since = command.since;
+    let pid;
+    let first = true;
+    let announce = false;
+    let backoff = 250;
+    let deleted = false;
+    let lastFailure;
+    const timer = yield* FiberHandle.make();
+    let pending = false;
+    let settleVersion = 0;
+    let settleBy = [];
+    const settled = (delay) => Effect10.sleep(delay).pipe(Effect10.andThen(Effect10.uninterruptible(Effect10.suspend(() => {
+      const version = settleVersion;
+      const by = settleBy;
+      pending = false;
+      settleBy = [];
+      const byText = by.join(", ");
+      return outputText(command.options, `Settled at version ${version}${byText ? ` by ${byText}` : ""}`, { event: "settled", version, by });
+    }))));
+    const schedule = (version, by) => Effect10.suspend(() => {
+      if (command.settle === undefined)
+        return Effect10.void;
+      const authors = authorText(by).split(", ").filter(Boolean);
+      settleVersion = version;
+      settleBy = [...new Set(pending ? [...settleBy, ...authors] : authors)];
+      pending = true;
+      return FiberHandle.run(timer, settled(Duration.millis(command.settle * 1000))).pipe(Effect10.asVoid);
+    });
+    while (!deleted) {
+      const daemon = yield* Effect10.exit(ensureDaemon());
+      if (Exit.isFailure(daemon)) {
+        if (Cause.hasInterruptsOnly(daemon.cause))
+          break;
+        const failure = Cause.squash(daemon.cause);
+        const tag = errorTag(failure);
+        if (tag !== "DaemonUnavailable") {
+          const message = errorMessage(failure);
+          if (message !== lastFailure)
+            yield* outputText(command.options, `Watch failed: ${message}, retrying`, { event: "error", message });
+          lastFailure = message;
+        } else
+          lastFailure = undefined;
+        yield* Effect10.sleep(`${backoff} millis`);
+        backoff = Math.min(5000, backoff * 2);
+        continue;
+      }
+      const info = daemon.value;
+      if (pid !== undefined && pid !== info.pid)
+        announce = true;
+      pid = info.pid;
+      const payload = { path: command.path, ...since === undefined ? {} : { since }, ...command.section === undefined ? {} : { section: command.section }, text: false };
+      const exit = yield* Effect10.exit(rpc(info, (client) => client.watch(payload).pipe(Stream2.runForEach((event) => Effect10.gen(function* () {
+        lastFailure = undefined;
+        if (event._tag === "Watching") {
+          backoff = 250;
+          if (first) {
+            yield* initialWatchOutput(command, event.version);
+            first = false;
+          } else if (announce) {
+            yield* restartOutput(command, event.version);
+            announce = false;
+          }
+          since = event.version;
+          return;
+        }
+        if (event._tag === "Resync") {
+          yield* resyncOutput(command, event.version);
+          if (command.settle !== undefined)
+            yield* schedule(event.version, []);
+          since = event.version;
+          announce = false;
+          return;
+        }
+        if (event._tag === "Deleted") {
+          yield* deletedOutput(command);
+          deleted = true;
+          return;
+        }
+        since = event.to;
+        if (sameAgent(event.by, command.options.as))
+          return;
+        if (command.settle !== undefined) {
+          yield* schedule(event.to, event.by);
+          return;
+        }
+        if (command.todos) {
+          if (!event.todos.length)
+            return;
+          if (command.options.json)
+            yield* writeJson(changeJson(event));
+          else
+            yield* writeLine(todosText(event.todos));
+        } else if (command.options.json)
+          yield* writeJson(changeJson(event));
+        else
+          yield* writeLine(changeReply(event, false));
+      })))));
+      if (deleted)
+        break;
+      if (Exit.isFailure(exit)) {
+        if (Cause.hasInterruptsOnly(exit.cause))
+          break;
+        const failure = Cause.squash(exit.cause);
+        const tag = errorTag(failure);
+        if (tag === "DocumentGone" || tag === "Refused")
+          return yield* errorResult(command, failure);
+        if (tag !== "DaemonUnavailable" && tag !== "RpcClientError") {
+          const message = errorMessage(failure);
+          if (message !== lastFailure)
+            yield* outputText(command.options, `Watch failed: ${message}, retrying`, { event: "error", message });
+          lastFailure = message;
+        } else
+          lastFailure = undefined;
+      } else
+        lastFailure = undefined;
+      yield* Effect10.sleep(`${backoff} millis`);
+      backoff = Math.min(5000, backoff * 2);
+    }
+    return deleted ? 9 : 0;
+  }));
+}
+function commandEffect(command) {
+  switch (command.kind) {
+    case "open":
+      return openCommand(command);
+    case "read":
+      return readCommand(command);
+    case "sections":
+      return sectionsCommand(command);
+    case "edit":
+    case "append":
+    case "todo-add":
+    case "todo-set":
+    case "todo-start":
+      return editCommand(command);
+    case "todo-list":
+      return todoListCommand(command);
+    case "diff":
+      return diffCommand(command);
+    case "watch":
+      return watchCommand(command);
+    case "status":
+      return statusCommand(command);
+    case "stop":
+      return stopCommand(command);
+    case "skill-install":
+      return skillInstallCommand(command);
+    case "skill-path":
+      return skillPathCommand(command);
+    case "skill-show":
+      return skillShowCommand(command);
+  }
+}
+function errorResult(command, error) {
+  return Effect10.gen(function* () {
+    const requested = ("version" in command ? command.version : ("since" in command) ? command.since : 0) ?? 0;
+    const tag = errorTag(error);
+    if (command.kind === "status" && tag === "DaemonUnavailable") {
+      yield* outputText(command.options, "Not running", { error: { code: "DaemonUnavailable", message: "Not running" } });
+      return 3;
+    }
+    if (tag === "VersionMismatch" || tag === "Forgotten") {
+      const reply = mismatchReply(error, requested);
+      const { kind: _kind, ...fields } = reply.json;
+      yield* outputText(command.options, reply.text, { error: { code: tag, message: reply.text, ...fields } });
+      return 1;
+    }
+    const code = rpcExitCode(error);
+    const message = tag === "NothingYet" && command.kind === "diff" ? `No change since version ${command.since} in ${command.wait} ${command.wait === 1 ? "second" : "seconds"}` : errorMessage(error);
+    const fields = errorFields(error);
+    yield* outputText(command.options, message, { error: { code: rpcErrorCode(error), message, ...fields } });
+    return code;
+  });
+}
+function program() {
+  let commandExit = 0;
+  const cli = makeCli((command) => Effect10.gen(function* () {
+    const result = yield* Effect10.exit(commandEffect(command));
+    commandExit = Exit.isSuccess(result) ? result.value : yield* errorResult(command, Cause.squash(result.cause));
+  }));
+  return Effect10.gen(function* () {
+    const args = yield* (yield* Stdio2.Stdio).args;
+    const input = normalizeArgv(args);
+    const result = yield* Effect10.exit(Command2.runWith(cli, { version: APP_VERSION, renderErrors: true })(input).pipe(Effect10.provide(CliConfig2.layer(cliConfigFor(input))), Effect10.provide(CliOutput2.layer(cliFormatter)), Effect10.provide(cliPresenter)));
+    if (Exit.isFailure(result)) {
+      const message = errorMessage(Cause.squash(result.cause));
+      if (args.includes("--json"))
+        yield* writeJson({ error: { code: "invalid", message } });
+      else
+        yield* writeLine(message);
+      return 2;
+    }
+    return commandExit;
+  }).pipe(Effect10.provide(BunServices.layer));
+}
+var main = program();
+BunRuntime.runMain(main, { disableErrorReporting: true, teardown: (exit, done) => done(Exit.isSuccess(exit) ? Number(exit.value) : 1) });