@fdcn/sourcefed 0.2.0

package/dist/pi.js

@@ -0,0 +1,249 @@
+import {
+  connectDaemonClient,
+  daemonCommand,
+  daemonEnvironment,
+  spawnLocalDaemon
+} from "./chunk-B7T6IZYS.js";
+import "./chunk-MLKGABMK.js";
+
+// adapters/pi/src/index.ts
+import { fileURLToPath } from "node:url";
+import { Type } from "typebox";
+
+// adapters/pi/src/dialog.ts
+import { Container, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+function showSourcefedDialog(_tui, theme, done, title, lines) {
+  const container = new Container();
+  container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+  container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+  container.addChild(new Spacer(1));
+  for (const line of lines) {
+    container.addChild(new Text(line.text, 1, 0));
+  }
+  container.addChild(new Spacer(1));
+  container.addChild(new Text(theme.fg("dim", "esc to close"), 1, 0));
+  container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+  return {
+    render: (width) => {
+      const rendered = container.render(width);
+      return rendered.map((line) => truncateToWidth(line, width));
+    },
+    invalidate: () => container.invalidate(),
+    handleInput: (data) => {
+      if (data === "\x1B" || data === "\r") done(null);
+    }
+  };
+}
+function monitorLines(monitors, theme) {
+  const active = monitors.filter((monitor) => monitor.enabled);
+  if (active.length === 0) return [{ text: theme.fg("dim", "No active monitors") }];
+  return active.map((monitor) => {
+    const status = monitor.unresponsive ? theme.fg("error", "\u25CF") : theme.fg("success", "\u25CF");
+    const describe = theme.fg("text", monitor.describe);
+    const detail = monitor.detail ? theme.fg("muted", monitor.detail) : "";
+    return { text: `${status} ${monitor.icon} ${describe}${detail}` };
+  });
+}
+function logLines(logs, theme) {
+  if (logs.length === 0) return [{ text: theme.fg("dim", "No notifications sent yet") }];
+  return logs.flatMap((entry) => {
+    const time = new Date(entry.at).toLocaleString();
+    const marker = entry.actionable ? theme.fg("warning", "\u25B6") : theme.fg("dim", "\xB7");
+    const summary = theme.fg("text", entry.summary);
+    const lines = [{ text: `${marker} ${entry.icon} ${theme.fg("muted", time)} ${summary}` }];
+    if (entry.body) lines.push({ text: theme.fg("muted", `  ${entry.body}`) });
+    return lines;
+  });
+}
+
+// adapters/pi/src/index.ts
+var STATUS_REFRESH_MS = 3e3;
+var SOURCE_ICONS = {
+  jira: "\u{F0303}",
+  github: "\u{F02A4}",
+  slack: "\u{F04B1}"
+};
+async function sourcefedExtension(pi) {
+  const listeners = /* @__PURE__ */ new Map();
+  let client;
+  let lastAttemptAt = 0;
+  let lastError;
+  let statusTimer;
+  let statusCtx;
+  pi.on("session_start", async (_event, ctx) => {
+    statusCtx = ctx;
+    await ensureTarget(ctx);
+    void refreshStatus();
+    statusTimer = setInterval(() => void refreshStatus(), STATUS_REFRESH_MS);
+  });
+  pi.on("session_shutdown", async () => {
+    if (statusTimer) clearInterval(statusTimer);
+    statusTimer = void 0;
+    statusCtx = void 0;
+    for (const listener of listeners.values()) await listener.close();
+    listeners.clear();
+    await client?.close();
+    client = void 0;
+  });
+  pi.registerTool({
+    name: "sourcefed_monitor_create",
+    label: "Sourcefed monitor create",
+    description: "Create or reuse a Sourcefed monitor for the current Pi session.",
+    parameters: Type.Object({
+      name: Type.String(),
+      sourceType: Type.Unsafe({ type: "string", enum: ["jira", "github", "slack"] }),
+      issueKey: Type.Optional(Type.String()),
+      repo: Type.Optional(Type.String()),
+      prNumber: Type.Optional(Type.Number()),
+      channelId: Type.Optional(Type.String()),
+      threadTs: Type.Optional(Type.String()),
+      threadUrl: Type.Optional(Type.String()),
+      pollIntervalSec: Type.Optional(Type.Number())
+    }),
+    execute: async (_toolCallID, input, _signal, _onUpdate, ctx) => toolResult(await call(ctx, "monitor_create", input))
+  });
+  pi.registerTool({
+    name: "sourcefed_monitor_list",
+    label: "Sourcefed monitor list",
+    description: "List Sourcefed monitors for the current Pi session.",
+    parameters: Type.Object({}),
+    execute: async (_toolCallID, _input, _signal, _onUpdate, ctx) => toolResult(await call(ctx, "monitor_list", {}))
+  });
+  pi.registerTool({
+    name: "sourcefed_monitor_status",
+    label: "Sourcefed monitor status",
+    description: "Read one Sourcefed monitor for the current Pi session.",
+    parameters: Type.Object({ id: Type.String() }),
+    execute: async (_toolCallID, input, _signal, _onUpdate, ctx) => toolResult(await call(ctx, "monitor_status", input))
+  });
+  pi.registerTool({
+    name: "sourcefed_monitor_stop",
+    label: "Sourcefed monitor stop",
+    description: "Stop one Sourcefed monitor for the current Pi session.",
+    parameters: Type.Object({ id: Type.String() }),
+    execute: async (_toolCallID, input, _signal, _onUpdate, ctx) => toolResult(await call(ctx, "monitor_stop", input))
+  });
+  pi.registerTool({
+    name: "sourcefed_monitor_start",
+    label: "Sourcefed monitor start",
+    description: "Start (re-enable) a stopped Sourcefed monitor for the current Pi session.",
+    parameters: Type.Object({ id: Type.String() }),
+    execute: async (_toolCallID, input, _signal, _onUpdate, ctx) => toolResult(await call(ctx, "monitor_start", input))
+  });
+  pi.registerCommand("sourcefed", {
+    description: "List Sourcefed monitors for the current Pi session",
+    handler: async (_args, ctx) => {
+      const result = await call(ctx, "monitor_list", {});
+      const monitors = Array.isArray(result?.monitors) ? result.monitors : [];
+      await ctx.ui.custom(
+        (tui, theme, _keybindings, done) => showSourcefedDialog(tui, theme, done, `Sourcefed monitors (${monitors.length})`, monitorLines(monitors, theme))
+      );
+    }
+  });
+  pi.registerCommand("sourcefed logs", {
+    description: "Show recent Sourcefed notifications for the current Pi session",
+    handler: async (_args, ctx) => {
+      const result = await call(ctx, "monitor_logs", {});
+      const logs = Array.isArray(result?.logs) ? result.logs : [];
+      await ctx.ui.custom(
+        (tui, theme, _keybindings, done) => showSourcefedDialog(tui, theme, done, `Sourcefed notifications (${logs.length})`, logLines(logs, theme))
+      );
+    }
+  });
+  async function refreshStatus() {
+    const ctx = statusCtx;
+    if (!ctx) return;
+    const result = await call(ctx, "monitor_list", {});
+    const monitors = Array.isArray(result?.monitors) ? result.monitors : [];
+    const active = monitors.filter((monitor) => monitor.enabled);
+    if (active.length === 0) {
+      ctx.ui.setStatus("sourcefed", void 0);
+      return;
+    }
+    const bySource = /* @__PURE__ */ new Map();
+    for (const monitor of active) {
+      const type = String(monitor.source && typeof monitor.source === "object" && "type" in monitor.source ? monitor.source.type : "");
+      const entry = bySource.get(type) ?? { count: 0, unresponsive: false };
+      entry.count += 1;
+      if (monitor.unresponsive) entry.unresponsive = true;
+      bySource.set(type, entry);
+    }
+    const parts = [...bySource.entries()].map(([type, entry]) => {
+      const icon = SOURCE_ICONS[type] ?? "?";
+      const colored = entry.unresponsive ? ctx.ui.theme.fg("error", icon) : ctx.ui.theme.fg("success", icon);
+      return `${colored}${entry.count}`;
+    });
+    ctx.ui.setStatus("sourcefed", parts.join(" "));
+  }
+  async function call(ctx, name, args) {
+    const target = await ensureTarget(ctx);
+    if (!client) return { ok: false, error: `sourcefed daemon unavailable: ${lastError ?? "not started"}` };
+    return client.request(name.replace(/_/g, "."), { ...args, target });
+  }
+  async function ensureTarget(ctx) {
+    await ensureClient();
+    const target = { kind: "pi-session", id: ctx.sessionManager.getSessionId() };
+    if (client && !listeners.has(target.id)) {
+      const listener = await client.subscribe(target, async (events) => {
+        await routeEvents(pi, events, target, client);
+      });
+      listeners.set(target.id, listener);
+    }
+    return target;
+  }
+  async function ensureClient() {
+    if (client) return;
+    if (Date.now() - lastAttemptAt < 15e3) return;
+    lastAttemptAt = Date.now();
+    try {
+      const url = process.env.SOURCEFED_DAEMON_URL;
+      if (url) {
+        client = await connectDaemonClient({ name: "sourcefed-pi", url });
+      } else {
+        const local = daemonCommand(cliEntry());
+        const spawned = await spawnLocalDaemon({
+          command: local.command,
+          args: local.args,
+          env: daemonEnvironment()
+        });
+        client = await connectDaemonClient({ name: "sourcefed-pi", url: spawned.url });
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      console.error(`[sourcefed] daemon unavailable: ${lastError}`);
+    }
+  }
+}
+async function routeEvents(pi, events, target, daemon) {
+  const delivered = [];
+  for (const queued of events) {
+    await pi.sendMessage({
+      customType: "sourcefed-monitor",
+      content: `[sourcefed monitor] ${queued.event.summary}${queued.event.body ? `
+
+${queued.event.body}` : ""}`,
+      display: true,
+      details: { actionable: queued.event.actionable, eventID: queued.id }
+    }, { triggerTurn: queued.event.actionable, deliverAs: "steer" });
+    delivered.push(queued);
+  }
+  if (delivered.length > 0) {
+    await daemon.request("monitor.ack", {
+      target,
+      eventIDs: delivered.map((queued) => queued.id)
+    });
+  }
+}
+function cliEntry() {
+  return fileURLToPath(import.meta.resolve("@sourcefed/cli"));
+}
+function toolResult(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }],
+    details: {}
+  };
+}
+export {
+  sourcefedExtension as default
+};