avtc-pi-featyard 1.1.0

package/src/commands/kanban-commands.ts

@@ -0,0 +1,278 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 avtc <tarasenkov@gmail.com>
+
+/**
+ * Register kanban UI commands (/fy:kanban, /fy:kanban-release) + the shared kanban
+ * HTTP server management + agent-lookup helpers shared by the auto-agent loop.
+ * The add_to_backlog tool lives separately in tools/add-to-backlog.ts.
+ */
+
+import type { Server } from "node:http";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { KanbanDatabase } from "../kanban/data/kanban-database.js";
+import type { KanbanContext } from "../kanban/kanban-context.js";
+import { createGenerateTitleCallback } from "../kanban/kanban-generate-title.js";
+import { createServer } from "../kanban/kanban-server.js";
+import { log } from "../log.js";
+import { DEFAULT_GLOBAL_DIR, getSettings, loadFeatyardConfig, NO_CWD_OVERRIDE } from "../settings/settings-ui.js";
+
+/** AutoAgentStateMachine (type-only alias to avoid repeating the inline import across findAgent* helpers). */
+type AutoAgent = import("../kanban/auto-agent/auto-agent-state-machine.js").AutoAgentStateMachine;
+/** Result shape of findAgentForSlug / findAgentByStates: a matched state machine + its kanban feature id, or null. */
+type AutoAgentMatch = { sm: AutoAgent; featureId: number } | null;
+
+/** Shared server instance — module-level for same-factory access. */
+let _sharedServer: { server: Server; port: number; authToken: string } | null = null;
+
+/** Get the shared server info. */
+export function getSharedServer(): { server: Server; port: number; authToken: string } | null {
+  return _sharedServer;
+}
+
+/** Set the shared server info. */
+export function setSharedServer(info: { server: Server; port: number; authToken: string } | null): void {
+  _sharedServer = info;
+}
+
+/** Sentinel for setSharedServer() — tear down / clear the shared server reference. */
+export const NO_SHARED_SERVER: { server: Server; port: number; authToken: string } | null = null;
+
+/** Returns true if the error is an EADDRINUSE (port already in use) error. */
+function isAddressInUseError(err: unknown): boolean {
+  if (err && typeof err === "object" && "code" in err) {
+    const code = (err as Record<string, unknown>).code;
+    if (code === "EADDRINUSE") return true;
+  }
+  if (err && typeof err === "object" && "message" in err) {
+    const message = (err as Record<string, unknown>).message;
+    if (typeof message === "string" && message.includes("EADDRINUSE")) return true;
+  }
+  return false;
+}
+
+/**
+ * When the kanban server port is already in use, try to connect to the
+ * existing server by reading the persisted auth token and verifying it's alive.
+ * Returns true on success (shared server is set), false on failure (user notified).
+ */
+async function tryConnectToExistingServer(
+  dataDir: string,
+  port: number,
+  notify: (msg: string, level: "info" | "warning" | "error") => void,
+): Promise<boolean> {
+  log.info(`[kanban] port ${port} already in use, attempting to connect to existing server`);
+  const tokenFile = join(dataDir, "auth_token.txt");
+  const fs = await import("node:fs");
+
+  // Read auth token
+  if (!fs.existsSync(tokenFile)) {
+    notify(
+      `Kanban server on port ${port} is running but has no auth token (likely started before multi-project support). ` +
+        `Please restart the other pi session so it writes the token, or kill the process on port ${port} and retry.`,
+      "error",
+    );
+    return false;
+  }
+  let savedToken: string;
+  try {
+    savedToken = fs.readFileSync(tokenFile, "utf-8").trim();
+  } catch (err) {
+    log.warn(`[kanban] failed to read auth token: ${err}`);
+    notify(`Failed to connect to existing kanban server: ${err}`, "error");
+    return false;
+  }
+
+  // Verify server is alive (5s timeout)
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    const res = await globalThis
+      .fetch(`http://localhost:${port}/api/projects`, {
+        headers: { Authorization: `Bearer ${savedToken}` },
+        signal: controller.signal,
+      })
+      .finally(() => clearTimeout(timeout));
+
+    if (!res.ok) {
+      notify(`Kanban server on port ${port} is not responding. Try stopping the other session first.`, "error");
+      return false;
+    }
+
+    setSharedServer({ server: { close: () => {} } as unknown as Server, port, authToken: savedToken });
+    log.info(`[kanban] connected to existing kanban server on port ${port}`);
+    notify(`Connected to existing kanban server on port ${port}`, "info");
+    return true;
+  } catch {
+    notify(`Kanban server on port ${port} is not reachable. Try stopping the other session first.`, "error");
+    return false;
+  }
+}
+
+/** Register the kanban UI slash commands (/fy:kanban, /fy:kanban-release). */
+export function registerKanbanCommands(pi: ExtensionAPI, ctx: KanbanContext): void {
+  const { getDatabase, getTools } = ctx;
+
+  // Register /fy:kanban command
+  pi.registerCommand("fy:kanban", {
+    description: "Open kanban board in browser (starts HTTP server if needed)",
+    async handler(_args, cmdCtx) {
+      const database = await getDatabase();
+      const config = loadFeatyardConfig(DEFAULT_GLOBAL_DIR, NO_CWD_OVERRIDE);
+      const desiredPort = config["kanban-port"] ?? 0;
+      const dataDir = join(homedir(), ".pi", "featyard", "kanban");
+      const staticDir = join(__dirname, "../kanban/kanban-board-ui");
+
+      if (!getSharedServer()) {
+        try {
+          setSharedServer(
+            await createServer(database, desiredPort, staticDir, {
+              doneHideAfterMs: getSettings().kanbanDoneHideAfterMs ?? null,
+              generateTitle: await createGenerateTitleCallback(
+                () => ctx.capturedModelRef.model,
+                () => ctx.capturedModelRef.registry,
+                await import("@earendil-works/pi-agent-core"),
+              ),
+              dataDir,
+            }),
+          );
+        } catch (err: unknown) {
+          if (!isAddressInUseError(err)) throw err;
+          if (!(await tryConnectToExistingServer(dataDir, desiredPort, cmdCtx.ui.notify.bind(cmdCtx.ui)))) return;
+        }
+      }
+      // Auto-detect or create project from git repo
+      const { detectProject } = await import("../kanban/data/kanban-detect-project.js");
+      let projectId = await detectProject(database, process.cwd());
+      if (!projectId) {
+        // Auto-create project for this repo
+        try {
+          const { resolveRepoPath } = await import("../kanban/data/kanban-detect-project.js");
+          const repoPath = await resolveRepoPath(process.cwd());
+          const existing = database.findProjectByRepoPath(repoPath);
+          if (existing) {
+            projectId = existing.id;
+          } else {
+            projectId = database.createProject({ name: basename(repoPath), repoPath });
+            log.info(`[kanban] auto-created project ${projectId} "${basename(repoPath)}" for repoPath=${repoPath}`);
+          }
+        } catch (err) {
+          log.warn(`[kanban] failed to auto-create project: ${err}`);
+        }
+      }
+      const server = getSharedServer();
+      if (!server) {
+        log.warn("[kanban] no shared server available, cannot open Kanban board");
+        return;
+      }
+      const url = projectId
+        ? `http://localhost:${server.port}?project=${projectId}`
+        : `http://localhost:${server.port}`;
+      cmdCtx.ui.notify(`Kanban board: ${url}`, "info");
+      // Open in browser (platform-specific)
+      const { execFile } = await import("node:child_process");
+      if (process.platform === "win32") {
+        execFile("cmd", ["/c", "start", "", url], () => {});
+      } else if (process.platform === "darwin") {
+        execFile("open", [url], () => {});
+      } else {
+        execFile("xdg-open", [url], () => {});
+      }
+    },
+  });
+
+  // Register /fy:kanban-release command
+  pi.registerCommand("fy:kanban-release", {
+    description: "Release a feature lock so others can pick it up",
+    async handler(args, cmdCtx) {
+      const featureId = parseInt(args.trim(), 10);
+      if (!featureId || featureId <= 0) {
+        cmdCtx.ui.notify("Usage: /fy:kanban-release <feature-id>", "warning");
+        return;
+      }
+
+      try {
+        const kanbanTools = await getTools();
+        kanbanTools.kanbanRelease({ featureId });
+        cmdCtx.ui.notify(`Feature ${featureId} lock released`, "info");
+      } catch (err) {
+        cmdCtx.ui.notify(`Failed to release feature ${featureId}: ${err}`, "error");
+      }
+    },
+  });
+}
+
+/** Helper: find an agent whose current feature matches the given slug. */
+export async function findAgentForSlug(
+  slug: string,
+  autoAgent: AutoAgent | null,
+  getDatabase: () => Promise<KanbanDatabase>,
+  options: { state: string | string[] | null } | null,
+): Promise<AutoAgentMatch> {
+  if (!autoAgent) return null;
+  const sm = autoAgent;
+  if (options?.state) {
+    const states = Array.isArray(options.state) ? options.state : [options.state];
+    if (!states.includes(sm.getState())) {
+      log.debug(`[kanban] findAgentForSlug("${slug}"): agent state=${sm.getState()} not in [${states.join(", ")}]`);
+      return null;
+    }
+  }
+  const featureId = sm.getCurrentFeatureId();
+  if (featureId === null) return null;
+  try {
+    const db = await getDatabase();
+    const feature = db.getFeature(featureId);
+    if (!feature || feature.slug !== slug) {
+      log.info(
+        `[kanban] findAgentForSlug("${slug}"): feature ${featureId} slug=${feature?.slug ?? "null"} !== ${slug}`,
+      );
+      return null;
+    }
+  } catch (err) {
+    log.warn(`[kanban] findAgentForSlug: lookup failed for slug "${slug}", featureId=${featureId}: ${err}`);
+    return null;
+  }
+  return { sm, featureId };
+}
+
+/** Find an agent for the given slug whose state is in `states`. Shared backing for findAnyActiveAgent/findResumableAgent. */
+function findAgentByStates(
+  slug: string,
+  autoAgent: AutoAgent | null,
+  getDatabase: () => Promise<KanbanDatabase>,
+  states: readonly string[],
+): Promise<AutoAgentMatch> {
+  return findAgentForSlug(slug, autoAgent, getDatabase, { state: [...states] });
+}
+
+/** Active agent states — any agent that is currently doing work or temporarily paused. */
+const ACTIVE_STATES = ["working", "paused", "waiting"] as const;
+
+/** Resumable agent states — agents waiting for user input. */
+const RESUMABLE_STATES = ["waiting"] as const;
+
+/**
+ * Find any active agent for the given slug (working, paused, or waiting).
+ * Convenience wrapper around findAgentForSlug that replaces cascading nullish coalescing.
+ */
+export function findAnyActiveAgent(
+  slug: string,
+  autoAgent: AutoAgent | null,
+  getDatabase: () => Promise<KanbanDatabase>,
+): Promise<AutoAgentMatch> {
+  return findAgentByStates(slug, autoAgent, getDatabase, ACTIVE_STATES);
+}
+
+/**
+ * Find a resumable agent for the given slug (waiting).
+ * Convenience wrapper around findAgentForSlug that replaces cascading nullish coalescing.
+ */
+export function findResumableAgent(
+  slug: string,
+  autoAgent: AutoAgent | null,
+  getDatabase: () => Promise<KanbanDatabase>,
+): Promise<AutoAgentMatch> {
+  return findAgentByStates(slug, autoAgent, getDatabase, RESUMABLE_STATES);
+}