speckit-kit 0.0.0

package/dist/bin/speckit-kit.js

@@ -0,0 +1,643 @@
+#!/usr/bin/env node
+
+// src/bin/speckit-kit.ts
+import fs3 from "fs";
+import { createServer } from "http";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { HttpApiBuilder as HttpApiBuilder3, HttpMiddleware, HttpServer, HttpServerRequest, HttpServerResponse } from "@effect/platform";
+import { NodeFileSystem, NodeHttpServer, NodePath, NodeRuntime } from "@effect/platform-node";
+import { Effect as Effect5, Layer as Layer2 } from "effect";
+import open from "open";
+
+// src/server/app/effect-api.ts
+import { HttpApi } from "@effect/platform";
+
+// src/server/health/health.contract.ts
+import { HttpApiEndpoint, HttpApiGroup } from "@effect/platform";
+import { Schema } from "effect";
+var HealthResponse = Schema.Struct({
+  ok: Schema.Boolean
+});
+var HealthGroup = HttpApiGroup.make("Health").add(HttpApiEndpoint.get("health")`/health`.addSuccess(HealthResponse));
+
+// src/server/specboard/specboard.contract.ts
+import { HttpApiEndpoint as HttpApiEndpoint2, HttpApiGroup as HttpApiGroup2, HttpApiSchema } from "@effect/platform";
+import { Schema as Schema2 } from "effect";
+var ArtifactName = Schema2.Union(
+  Schema2.Literal("spec.md"),
+  Schema2.Literal("plan.md"),
+  Schema2.Literal("tasks.md"),
+  Schema2.Literal("quickstart.md"),
+  Schema2.Literal("data-model.md"),
+  Schema2.Literal("research.md")
+);
+var SpecTaskStats = Schema2.Struct({
+  total: Schema2.Number,
+  done: Schema2.Number,
+  todo: Schema2.Number
+});
+var SpecListItem = Schema2.Struct({
+  id: Schema2.String,
+  num: Schema2.Number,
+  title: Schema2.String,
+  taskStats: Schema2.optional(SpecTaskStats)
+});
+var SpecListResponse = Schema2.Struct({
+  items: Schema2.Array(SpecListItem)
+});
+var TaskItem = Schema2.Struct({
+  line: Schema2.Number,
+  checked: Schema2.Boolean,
+  raw: Schema2.String,
+  title: Schema2.String,
+  taskId: Schema2.optional(Schema2.String),
+  parallel: Schema2.optional(Schema2.Boolean),
+  story: Schema2.optional(Schema2.String)
+});
+var TaskListResponse = Schema2.Struct({
+  specId: Schema2.String,
+  tasks: Schema2.Array(TaskItem)
+});
+var TaskToggleRequest = Schema2.Struct({
+  line: Schema2.Number,
+  checked: Schema2.Boolean
+});
+var FileReadResponse = Schema2.Struct({
+  name: ArtifactName,
+  path: Schema2.String,
+  content: Schema2.String
+});
+var FileWriteRequest = Schema2.Struct({
+  content: Schema2.String
+});
+var FileWriteResponse = Schema2.Struct({
+  name: ArtifactName,
+  path: Schema2.String
+});
+var ValidationError = Schema2.Struct({
+  _tag: Schema2.Literal("ValidationError"),
+  message: Schema2.String
+});
+var NotFoundError = Schema2.Struct({
+  _tag: Schema2.Literal("NotFoundError"),
+  message: Schema2.String
+});
+var ForbiddenError = Schema2.Struct({
+  _tag: Schema2.Literal("ForbiddenError"),
+  message: Schema2.String
+});
+var ConflictError = Schema2.Struct({
+  _tag: Schema2.Literal("ConflictError"),
+  message: Schema2.String
+});
+var InternalError = Schema2.Struct({
+  _tag: Schema2.Literal("InternalError"),
+  message: Schema2.String
+});
+var SpecboardGroup = HttpApiGroup2.make("Specboard").addError(ValidationError, { status: 400 }).addError(ForbiddenError, { status: 403 }).addError(NotFoundError, { status: 404 }).addError(ConflictError, { status: 409 }).addError(InternalError, { status: 500 }).add(HttpApiEndpoint2.get("specList")`/specs`.addSuccess(SpecListResponse)).add(
+  HttpApiEndpoint2.get("taskList")`/specs/${HttpApiSchema.param("specId", Schema2.String)}/tasks`.addSuccess(
+    TaskListResponse
+  )
+).add(
+  HttpApiEndpoint2.post("taskToggle")`/specs/${HttpApiSchema.param("specId", Schema2.String)}/tasks/toggle`.setPayload(TaskToggleRequest).addSuccess(TaskListResponse)
+).add(
+  HttpApiEndpoint2.get(
+    "fileRead"
+  )`/specs/${HttpApiSchema.param("specId", Schema2.String)}/files/${HttpApiSchema.param("name", ArtifactName)}`.addSuccess(
+    FileReadResponse
+  )
+).add(
+  HttpApiEndpoint2.put(
+    "fileWrite"
+  )`/specs/${HttpApiSchema.param("specId", Schema2.String)}/files/${HttpApiSchema.param("name", ArtifactName)}`.setPayload(FileWriteRequest).addSuccess(FileWriteResponse)
+);
+
+// src/server/app/effect-api.ts
+var EffectApi = HttpApi.make("EffectApi").add(HealthGroup).add(SpecboardGroup);
+
+// src/server/health/health.http.live.ts
+import { HttpApiBuilder } from "@effect/platform";
+import { Effect } from "effect";
+var HealthLive = HttpApiBuilder.group(
+  EffectApi,
+  "Health",
+  (handlers) => handlers.handle("health", () => Effect.succeed({ ok: true }))
+);
+
+// src/server/specboard/specboard.http.live.ts
+import { HttpApiBuilder as HttpApiBuilder2 } from "@effect/platform";
+import { Effect as Effect3 } from "effect";
+
+// src/server/specboard/specboard.service.ts
+import { Context } from "effect";
+var Specboard = class extends Context.Tag("Specboard")() {
+};
+
+// src/server/specboard/specboard.http.live.ts
+var SpecboardLive = HttpApiBuilder2.group(
+  EffectApi,
+  "Specboard",
+  (handlers) => handlers.handle(
+    "specList",
+    () => Effect3.gen(function* () {
+      const specboard = yield* Specboard;
+      return yield* specboard.listSpecs;
+    })
+  ).handle(
+    "taskList",
+    ({ path: path4 }) => Effect3.gen(function* () {
+      const specboard = yield* Specboard;
+      return yield* specboard.listTasks(path4.specId);
+    })
+  ).handle(
+    "taskToggle",
+    ({ path: path4, payload }) => Effect3.gen(function* () {
+      const specboard = yield* Specboard;
+      return yield* specboard.toggleTask({ specId: path4.specId, line: payload.line, checked: payload.checked });
+    })
+  ).handle(
+    "fileRead",
+    ({ path: path4 }) => Effect3.gen(function* () {
+      const specboard = yield* Specboard;
+      return yield* specboard.readFile({ specId: path4.specId, name: path4.name });
+    })
+  ).handle(
+    "fileWrite",
+    ({ path: path4, payload }) => Effect3.gen(function* () {
+      const specboard = yield* Specboard;
+      return yield* specboard.writeFile({ specId: path4.specId, name: path4.name, content: payload.content });
+    })
+  )
+);
+
+// src/server/specboard/specboard.service.live.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { Effect as Effect4, Layer } from "effect";
+
+// src/server/util/repo-paths.ts
+import fs from "fs";
+import path from "path";
+var RepoRootNotFoundError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "RepoRootNotFoundError";
+  }
+};
+var UnsafePathSegmentError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "UnsafePathSegmentError";
+  }
+};
+var PathEscapeError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "PathEscapeError";
+  }
+};
+function findRepoPaths(startDir = process.cwd()) {
+  const envRepoRoot = process.env.SPECKIT_KIT_REPO_ROOT ?? process.env.SPECKIT_REPO_ROOT;
+  if (envRepoRoot) {
+    const repoRoot = path.resolve(envRepoRoot);
+    const specsRoot = path.join(repoRoot, "specs");
+    if (!fs.existsSync(specsRoot) || !fs.statSync(specsRoot).isDirectory()) {
+      throw new RepoRootNotFoundError(`Invalid repo root: specs/ not found under ${repoRoot}`);
+    }
+    return { repoRoot, specsRoot };
+  }
+  let dir = path.resolve(startDir);
+  while (true) {
+    const specsRoot = path.join(dir, "specs");
+    if (fs.existsSync(specsRoot) && fs.statSync(specsRoot).isDirectory()) {
+      return { repoRoot: dir, specsRoot };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new RepoRootNotFoundError(`Cannot locate repo root starting from: ${startDir}`);
+}
+function resolveWithinRoot(rootDir, relativePath) {
+  const rootAbs = path.resolve(rootDir);
+  const targetAbs = path.resolve(rootAbs, relativePath);
+  const rootPrefix = rootAbs.endsWith(path.sep) ? rootAbs : `${rootAbs}${path.sep}`;
+  if (!targetAbs.startsWith(rootPrefix)) {
+    throw new PathEscapeError(`Path escapes root: ${relativePath}`);
+  }
+  return targetAbs;
+}
+function assertSafePathSegment(segment) {
+  if (segment.includes("/") || segment.includes("\\")) {
+    throw new UnsafePathSegmentError("Path segment contains separator");
+  }
+}
+
+// src/server/specboard/specboard.tasks.ts
+var CheckboxLine = /^(\s*-\s*\[)([ xX])(\]\s+)(.+)$/;
+function parseTasksMarkdown(markdown) {
+  const tasks = [];
+  const lines = markdown.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const raw = lines[index] ?? "";
+    const match = raw.match(CheckboxLine);
+    if (!match) continue;
+    const checked = match[2]?.toLowerCase() === "x";
+    const title = match[4]?.trim() ?? "";
+    const taskId = title.match(/\bT\d{3}\b/)?.[0];
+    const parallel = /\[P\]/.test(title) ? true : void 0;
+    const story = title.match(/\[(US\d+)\]/)?.[1];
+    tasks.push({
+      line: index + 1,
+      checked,
+      raw,
+      title,
+      taskId,
+      parallel,
+      story
+    });
+  }
+  return tasks;
+}
+function updateCheckboxLine(rawLine, checked) {
+  const match = rawLine.match(CheckboxLine);
+  if (!match) return null;
+  const prefix = match[1] ?? "";
+  const suffix = `${match[3] ?? ""}${match[4] ?? ""}`;
+  return `${prefix}${checked ? "x" : " "}${suffix}`;
+}
+
+// src/server/specboard/specboard.service.live.ts
+function toInternalError(message) {
+  return { _tag: "InternalError", message };
+}
+function toFsError(e) {
+  if (e instanceof UnsafePathSegmentError || e instanceof PathEscapeError) {
+    return { _tag: "ForbiddenError", message: "Forbidden path" };
+  }
+  if (typeof e === "object" && e !== null && "code" in e) {
+    const code = e.code;
+    if (code === "ENOENT") return { _tag: "NotFoundError", message: "File not found" };
+    if (code === "EACCES" || code === "EPERM") return { _tag: "ForbiddenError", message: "Permission denied" };
+  }
+  return toInternalError(e instanceof Error ? e.message : "Internal error");
+}
+function inferTitleFromMarkdown(markdown, fallback) {
+  const line = markdown.split(/\r?\n/).find((l) => l.startsWith("# "));
+  return line ? line.replace(/^#\s+/, "").trim() : fallback;
+}
+function parseSpecDirName(dirName) {
+  if (!/^\d{3}-/.test(dirName)) return null;
+  const num = Number.parseInt(dirName.slice(0, 3), 10);
+  if (Number.isNaN(num)) return null;
+  return { id: dirName, num };
+}
+function specFileRelPath(specId, name) {
+  return path2.posix.join("specs", specId, name);
+}
+function absSpecDir(paths, specId) {
+  assertSafePathSegment(specId);
+  return resolveWithinRoot(paths.specsRoot, specId);
+}
+function absSpecFile(paths, specId, name) {
+  return resolveWithinRoot(absSpecDir(paths, specId), name);
+}
+async function exists(p) {
+  try {
+    await fs2.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeFileAtomic(absPath, content) {
+  const dir = path2.dirname(absPath);
+  const tmpPath = path2.join(dir, `.tmp.${path2.basename(absPath)}.${Date.now()}.${Math.random().toString(16).slice(2)}`);
+  await fs2.writeFile(tmpPath, content, "utf8");
+  await fs2.rename(tmpPath, absPath);
+}
+var SpecboardServiceLive = Layer.effect(
+  Specboard,
+  Effect4.sync(() => {
+    const pathsOrError = (() => {
+      try {
+        return findRepoPaths();
+      } catch (e) {
+        return toInternalError(e instanceof Error ? e.message : "Cannot find repo root");
+      }
+    })();
+    const isError = (u) => typeof u === "object" && u !== null && "_tag" in u;
+    const withPaths = (f) => isError(pathsOrError) ? Effect4.fail(pathsOrError) : f(pathsOrError);
+    const listSpecs = withPaths(
+      (paths) => Effect4.tryPromise({
+        try: async () => {
+          const dirents = await fs2.readdir(paths.specsRoot, { withFileTypes: true });
+          const specs = dirents.filter((d) => d.isDirectory()).map((d) => parseSpecDirName(d.name)).filter((v) => v !== null);
+          const items = await Promise.all(
+            specs.map(async ({ id, num }) => {
+              const specMdPath = absSpecFile(paths, id, "spec.md");
+              const specMd = await exists(specMdPath) ? await fs2.readFile(specMdPath, "utf8") : null;
+              const tasksMdPath = absSpecFile(paths, id, "tasks.md");
+              const tasksMd = await exists(tasksMdPath) ? await fs2.readFile(tasksMdPath, "utf8") : null;
+              const tasks = tasksMd ? parseTasksMarkdown(tasksMd) : [];
+              const done = tasks.filter((t) => t.checked).length;
+              const total = tasks.length;
+              return {
+                id,
+                num,
+                title: specMd ? inferTitleFromMarkdown(specMd, id) : id,
+                taskStats: tasksMd ? {
+                  total,
+                  done,
+                  todo: total - done
+                } : void 0
+              };
+            })
+          );
+          items.sort((a, b) => b.num - a.num || b.id.localeCompare(a.id));
+          return { items };
+        },
+        catch: toFsError
+      })
+    );
+    const listTasks = (specId) => withPaths(
+      (paths) => Effect4.tryPromise({
+        try: async () => {
+          const tasksMdPath = absSpecFile(paths, specId, "tasks.md");
+          const tasksMd = await fs2.readFile(tasksMdPath, "utf8");
+          const tasks = parseTasksMarkdown(tasksMd);
+          return { specId, tasks };
+        },
+        catch: toFsError
+      })
+    );
+    const toggleTask = ({ specId, line, checked }) => withPaths(
+      (paths) => Effect4.tryPromise({
+        try: async () => {
+          if (!Number.isInteger(line) || line <= 0) {
+            return Promise.reject({ _tag: "ValidationError", message: "invalid line" });
+          }
+          const tasksMdPath = absSpecFile(paths, specId, "tasks.md");
+          const tasksMd = await fs2.readFile(tasksMdPath, "utf8");
+          const lines = tasksMd.split(/\r?\n/);
+          const idx = line - 1;
+          if (idx < 0 || idx >= lines.length) {
+            return Promise.reject({ _tag: "ValidationError", message: "line out of range" });
+          }
+          const updated = updateCheckboxLine(lines[idx] ?? "", checked);
+          if (!updated) {
+            return Promise.reject({
+              _tag: "ValidationError",
+              message: "target line is not a checkbox task"
+            });
+          }
+          lines[idx] = updated;
+          await writeFileAtomic(tasksMdPath, lines.join("\n"));
+          const nextTasksMd = await fs2.readFile(tasksMdPath, "utf8");
+          return { specId, tasks: parseTasksMarkdown(nextTasksMd) };
+        },
+        catch: (e) => {
+          if (typeof e === "object" && e !== null && "_tag" in e) {
+            const tag = e._tag;
+            if (tag === "ValidationError") {
+              return e;
+            }
+          }
+          return toFsError(e);
+        }
+      })
+    );
+    const readFile = ({ specId, name }) => withPaths(
+      (paths) => Effect4.tryPromise({
+        try: async () => {
+          const absPath = absSpecFile(paths, specId, name);
+          const content = await fs2.readFile(absPath, "utf8");
+          return { name, path: specFileRelPath(specId, name), content };
+        },
+        catch: toFsError
+      })
+    );
+    const writeFile = ({ specId, name, content }) => withPaths(
+      (paths) => Effect4.tryPromise({
+        try: async () => {
+          const specDir = absSpecDir(paths, specId);
+          if (!await exists(specDir)) {
+            return Promise.reject({ _tag: "NotFoundError", message: "Spec not found" });
+          }
+          const absPath = absSpecFile(paths, specId, name);
+          await writeFileAtomic(absPath, content);
+          return { name, path: specFileRelPath(specId, name) };
+        },
+        catch: (e) => {
+          if (typeof e === "object" && e !== null && "_tag" in e) {
+            const tag = e._tag;
+            if (tag === "NotFoundError") {
+              return e;
+            }
+          }
+          return toFsError(e);
+        }
+      })
+    );
+    return { listSpecs, listTasks, toggleTask, readFile, writeFile };
+  })
+);
+
+// src/bin/speckit-kit.ts
+function printHelp() {
+  console.log(`speckit-kit
+
+\u7528\u6CD5:
+  speckit-kit [kanban] [--repo-root <path>] [--host <host>] [--port <port>] [--no-open]
+
+\u53C2\u6570:
+  --repo-root <path>   \u6307\u5B9A\u76EE\u6807\u4ED3\u5E93\u6839\u76EE\u5F55\uFF08\u9700\u5305\u542B specs/\uFF09
+  --host <host>        \u76D1\u542C\u5730\u5740\uFF08\u9ED8\u8BA4 127.0.0.1\uFF09
+  --port <port>        \u76D1\u542C\u7AEF\u53E3\uFF08\u9ED8\u8BA4 0 \u968F\u673A\u7AEF\u53E3\uFF09
+  --no-open            \u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668
+  -h, --help           \u663E\u793A\u5E2E\u52A9
+`);
+}
+function parseArgs(argv) {
+  const args = [...argv];
+  const first = args[0];
+  let command = "kanban";
+  if (first && !first.startsWith("-")) {
+    if (first !== "kanban") {
+      throw new Error(`\u672A\u77E5\u547D\u4EE4\uFF1A${first}`);
+    }
+    command = "kanban";
+    args.shift();
+  }
+  let host = process.env.HOST ?? "127.0.0.1";
+  let port = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : null;
+  let shouldOpen = !(process.env.NO_OPEN === "1" || process.env.NO_OPEN === "true");
+  let repoRoot = null;
+  const takeValue = (flag) => {
+    const value = args.shift();
+    if (!value) throw new Error(`${flag} \u7F3A\u5C11\u53C2\u6570`);
+    return value;
+  };
+  while (args.length > 0) {
+    const a = args.shift();
+    if (a === "-h" || a === "--help") return { help: true };
+    if (a === "--host") {
+      host = takeValue(a);
+      continue;
+    }
+    if (a === "--port") {
+      const raw = takeValue(a);
+      port = Number.parseInt(raw, 10);
+      if (Number.isNaN(port) || port < 0) {
+        throw new Error(`--port \u975E\u6CD5\uFF1A${raw}`);
+      }
+      continue;
+    }
+    if (a === "--repo-root") {
+      repoRoot = takeValue(a);
+      continue;
+    }
+    if (a === "--no-open") {
+      shouldOpen = false;
+      continue;
+    }
+    if (a === "--open") {
+      shouldOpen = true;
+      continue;
+    }
+    throw new Error(`\u672A\u77E5\u53C2\u6570\uFF1A${a}`);
+  }
+  return { command, host, port, open: shouldOpen, repoRoot };
+}
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+var UI_DIST = path3.resolve(__dirname, "..", "ui");
+var UI_INDEX_HTML = path3.join(UI_DIST, "index.html");
+function assertUiDistExists() {
+  if (!fs3.existsSync(UI_INDEX_HTML)) {
+    console.error(`UI dist \u4E0D\u5B58\u5728\uFF1A${UI_DIST}`);
+    console.error(`\u8BF7\u5148\u6784\u5EFA\uFF1Apnpm -C packages/speckit-kit build`);
+    process.exit(1);
+  }
+}
+function stripApiPrefix(req) {
+  let url;
+  try {
+    url = new URL(req.url, "http://localhost");
+  } catch {
+    return req;
+  }
+  if (!(url.pathname === "/api" || url.pathname.startsWith("/api/"))) {
+    return req;
+  }
+  url.pathname = url.pathname.replace(/^\/api/, "") || "/";
+  const nextUrl = `${url.pathname}${url.search}`;
+  return req.modify({ url: nextUrl });
+}
+function resolveUiFilePath(pathname) {
+  const decoded = (() => {
+    try {
+      return decodeURIComponent(pathname);
+    } catch {
+      return pathname;
+    }
+  })();
+  const withoutLeadingSlash = decoded.startsWith("/") ? decoded.slice(1) : decoded;
+  const relative = withoutLeadingSlash.length === 0 ? "index.html" : withoutLeadingSlash;
+  const candidate = path3.resolve(UI_DIST, relative);
+  if (!candidate.startsWith(`${UI_DIST}${path3.sep}`) && candidate !== UI_DIST) {
+    return null;
+  }
+  if (decoded.endsWith("/") || !path3.extname(candidate)) {
+    return UI_INDEX_HTML;
+  }
+  return candidate;
+}
+function runKanban(opts) {
+  if (opts.repoRoot) {
+    process.env.SPECKIT_KIT_REPO_ROOT = path3.resolve(opts.repoRoot);
+  }
+  assertUiDistExists();
+  const ApiLive = HttpApiBuilder3.api(EffectApi).pipe(
+    Layer2.provide(HealthLive),
+    Layer2.provide(SpecboardLive),
+    Layer2.provide(SpecboardServiceLive)
+  );
+  const NodeServerLive = NodeHttpServer.layer(createServer, {
+    port: opts.port === null || Number.isNaN(opts.port) ? 0 : opts.port,
+    host: opts.host
+  });
+  const RuntimeLive = Layer2.mergeAll(
+    ApiLive,
+    HttpApiBuilder3.Router.Live,
+    HttpApiBuilder3.Middleware.layer,
+    NodeFileSystem.layer,
+    NodePath.layer,
+    NodeServerLive
+  );
+  const program = Effect5.gen(function* () {
+    const apiApp = yield* HttpApiBuilder3.httpApp;
+    const httpApp = Effect5.gen(function* () {
+      const req = yield* HttpServerRequest.HttpServerRequest;
+      let url;
+      try {
+        url = new URL(req.url, "http://localhost");
+      } catch {
+        url = new URL("http://localhost/");
+      }
+      if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+        const rewritten = stripApiPrefix(req);
+        return yield* apiApp.pipe(Effect5.provideService(HttpServerRequest.HttpServerRequest, rewritten));
+      }
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        return HttpServerResponse.text("Not Found", { status: 404 });
+      }
+      const filePath = resolveUiFilePath(url.pathname);
+      if (!filePath) {
+        return HttpServerResponse.text("Not Found", { status: 404 });
+      }
+      return yield* HttpServerResponse.file(filePath).pipe(
+        Effect5.catchAll(() => Effect5.succeed(HttpServerResponse.text("Not Found", { status: 404 })))
+      );
+    });
+    yield* HttpServer.serveEffect(httpApp, HttpMiddleware.logger);
+    const address = yield* HttpServer.addressWith(Effect5.succeed);
+    if (address._tag === "TcpAddress") {
+      const publicUrl = `http://localhost:${address.port}`;
+      yield* Effect5.sync(() => {
+        console.log(`Server running at ${publicUrl}`);
+      });
+      if (opts.open) {
+        yield* Effect5.tryPromise({
+          try: () => open(publicUrl),
+          catch: () => void 0
+        }).pipe(Effect5.ignore);
+      }
+    } else {
+      yield* Effect5.sync(() => {
+        console.log(`Server running at ${HttpServer.formatAddress(address)}`);
+      });
+    }
+    return yield* Effect5.never;
+  }).pipe(Effect5.provide(RuntimeLive), Effect5.scoped);
+  NodeRuntime.runMain(program);
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if ("help" in parsed) {
+    printHelp();
+    return;
+  }
+  if (parsed.command === "kanban") {
+    runKanban(parsed);
+    return;
+  }
+}
+void main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
+//# sourceMappingURL=speckit-kit.js.map