@plot-ai/linux-x64-musl 0.0.1 → 0.0.3

package/bin/CHANGELOG.md

@@ -1,5 +1,5 @@
 # changelog
 
-## 0.0.1
+## 0.0.3
 
 - packaged plot-ai release

package/bin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plot-ai/linux-x64-musl",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "piConfig": {
     "name": "plot",
     "configDir": ".plot"

package/bin/tui-worker.js

@@ -148024,7 +148024,7 @@ var require_lib4 = __commonJS((exports, module2) => {
 // packages/plot/src/tui-worker.ts
 import { Console } from "console";
 import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync9, readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname20 } from "path";
+import { dirname as dirname21 } from "path";
 
 // node_modules/.bun/effect@3.19.19/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -194228,8 +194228,8 @@ class ObservabilityApi extends exports_Effect.Service()("ObservabilityApi", {
 }
 
 // packages/plot/src/runtime-builder.ts
-import { existsSync as existsSync24, readdirSync as readdirSync12 } from "fs";
-import { dirname as dirname19, join as join34, resolve as resolve14 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync12 } from "fs";
+import { dirname as dirname20, join as join35, resolve as resolve14 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // node_modules/.bun/@effect+platform-bun@0.87.1+6d9c3e47916ac965/node_modules/@effect/platform-bun/dist/esm/BunContext.js
@@ -290688,9 +290688,189 @@ var PiAgentLive = exports_Layer.succeed(AgentService, AgentService.of({
   run: (config2) => createEventStream(config2)
 }));
 // packages/plot/src/tracker/beads/index.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// packages/plot/src/tracker/beads/daemon-transport.ts
 import { execFile } from "child_process";
+import { existsSync as existsSync24 } from "fs";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname19, join as join34 } from "path";
+import { createConnection } from "net";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+function walkUp(startDir, filename, globalFallback = false) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join34(dir, ".beads", filename);
+    if (existsSync24(candidate))
+      return candidate;
+    const parent = dirname19(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  if (globalFallback) {
+    const globalPath = join34(homedir14(), ".beads", filename);
+    if (existsSync24(globalPath))
+      return globalPath;
+  }
+  return null;
+}
+function findSocketPath(workspaceRoot) {
+  return walkUp(workspaceRoot, "bd.sock", true);
+}
+function findBeadsDirectory(workspaceRoot) {
+  let dir = workspaceRoot;
+  while (true) {
+    const candidate = join34(dir, ".beads");
+    if (existsSync24(candidate))
+      return candidate;
+    const parent = dirname19(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+
+class BeadsDaemonTransport {
+  workspaceRoot;
+  requestTimeoutMs;
+  actor;
+  socketPath = null;
+  constructor(workspaceRoot, requestTimeoutMs = 5000, actor = "plot") {
+    this.workspaceRoot = workspaceRoot;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.actor = actor;
+  }
+  async listAllIssues() {
+    return this.send("list", { status: "all" });
+  }
+  async listOpenIssues() {
+    return this.send("list", { limit: 0 });
+  }
+  async viewIssue(id3) {
+    return this.send("show", { id: id3 });
+  }
+  async send(operation, args2) {
+    const socketPath = await this.ensureRunning();
+    return await new Promise((resolve14, reject) => {
+      const socket = createConnection(socketPath);
+      let responseData = "";
+      let settled = false;
+      const settle = (fn2, value6) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timeout5);
+        fn2(value6);
+      };
+      const handleResponse = (raw2) => {
+        const trimmed2 = raw2.trim();
+        if (!trimmed2) {
+          settle(reject, new Error("beads daemon returned empty response"));
+          return;
+        }
+        try {
+          const response = JSON.parse(trimmed2);
+          if (response.success) {
+            settle(resolve14, response.data);
+            return;
+          }
+          settle(reject, new Error(response.error ?? "unknown beads daemon error"));
+        } catch {
+          settle(reject, new Error(`failed to parse beads daemon response: ${trimmed2}`));
+        }
+      };
+      const timeout5 = setTimeout(() => {
+        socket.destroy();
+        settle(reject, new Error(`beads daemon request timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      socket.on("connect", () => {
+        socket.write(JSON.stringify({
+          operation,
+          args: args2,
+          cwd: this.workspaceRoot,
+          actor: this.actor
+        }) + `
+`);
+      });
+      socket.on("data", (chunk5) => {
+        responseData += chunk5.toString();
+        if (responseData.includes(`
+`)) {
+          socket.destroy();
+          handleResponse(responseData);
+        }
+      });
+      socket.on("end", () => {
+        if (!settled && responseData.length > 0) {
+          handleResponse(responseData);
+          return;
+        }
+        if (!settled) {
+          settle(reject, new Error("beads daemon closed connection without a response"));
+        }
+      });
+      socket.on("error", (error4) => {
+        this.socketPath = null;
+        settle(reject, new Error(`beads daemon connection error: ${error4.message}`));
+      });
+    });
+  }
+  async ensureRunning() {
+    if (this.socketPath)
+      return this.socketPath;
+    const found = findSocketPath(this.workspaceRoot);
+    if (found) {
+      this.socketPath = found;
+      return found;
+    }
+    await this.startDaemon();
+    if (!this.socketPath)
+      throw new Error("beads daemon socket unavailable");
+    return this.socketPath;
+  }
+  async startDaemon() {
+    const beadsDirectory = findBeadsDirectory(this.workspaceRoot);
+    if (!beadsDirectory) {
+      throw new Error("no .beads directory found");
+    }
+    await execFileAsync("bd", ["daemon", "start"], {
+      cwd: this.workspaceRoot,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    const expectedSocketPath = join34(beadsDirectory, "bd.sock");
+    await new Promise((resolve14, reject) => {
+      const startedAt = Date.now();
+      const timer = setInterval(() => {
+        if (existsSync24(expectedSocketPath)) {
+          clearInterval(timer);
+          this.socketPath = expectedSocketPath;
+          resolve14();
+          return;
+        }
+        if (Date.now() - startedAt >= this.requestTimeoutMs) {
+          clearInterval(timer);
+          reject(new Error(`beads daemon socket did not appear within ${this.requestTimeoutMs}ms`));
+        }
+      }, 100);
+    });
+  }
+}
+async function tryCreateBeadsDaemonTransport(workspaceRoot) {
+  const transport = new BeadsDaemonTransport(workspaceRoot);
+  try {
+    await transport.listAllIssues();
+    return transport;
+  } catch {
+    return null;
+  }
+}
+
+// packages/plot/src/tracker/beads/index.ts
+var execFileAsync2 = promisify2(execFile2);
 var normalizeState2 = (s) => s.trim().toLowerCase();
 function mapBdFailure(error4, resourceId) {
   const message = error4 instanceof Error ? error4.message : String(error4);
@@ -290709,36 +290889,65 @@ function mapBdFailure(error4, resourceId) {
   }
   return new Error(`bd command failed: ${details}`);
 }
-function createBeadsOps(config2) {
+async function createBeadsOps(config2) {
+  const workspaceRoot = config2.beadsDir ?? process.cwd();
+  const daemon = await tryCreateBeadsDaemonTransport(workspaceRoot);
   const runBd = async (args2, options5) => {
     try {
-      return await execFileAsync("bd", args2, {
+      return await execFileAsync2("bd", args2, {
         maxBuffer: 50 * 1024 * 1024,
-        ...config2.beadsDir ? { cwd: config2.beadsDir } : {}
+        cwd: workspaceRoot
       });
     } catch (error4) {
       throw mapBdFailure(error4, options5?.resourceId);
     }
   };
+  const parseIssueList = (value6) => value6;
+  const parseDetailedIssue = (value6, id3) => {
+    const issue2 = Array.isArray(value6) ? value6[0] : value6;
+    if (!issue2)
+      throw new Error(`bd show returned empty result for ${id3}`);
+    return issue2;
+  };
+  const runDaemon = async (operation) => {
+    if (!daemon)
+      return null;
+    try {
+      return await operation(daemon);
+    } catch {
+      return null;
+    }
+  };
   const listIssues = async (status3) => {
+    const daemonResult = await runDaemon((transport) => transport.listAllIssues());
+    if (daemonResult) {
+      if (status3 === "all")
+        return daemonResult;
+      return daemonResult.filter((issue2) => normalizeState2(issue2.status) === normalizeState2(status3));
+    }
     const result = await runBd(["list", "--json", "--status", status3]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const listAllIssues = async () => {
+    const daemonResult = await runDaemon((transport) => transport.listAllIssues());
+    if (daemonResult)
+      return daemonResult;
     const result = await runBd(["list", "--json", "--status", "all"]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const listOpenIssues = async () => {
+    const daemonResult = await runDaemon((transport) => transport.listOpenIssues());
+    if (daemonResult)
+      return daemonResult;
     const result = await runBd(["list", "--json", "--limit", "0"]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const viewIssue = async (id3) => {
+    const daemonResult = await runDaemon((transport) => transport.viewIssue(id3));
+    if (daemonResult)
+      return parseDetailedIssue(daemonResult, id3);
     const result = await runBd(["show", id3, "--json"], { resourceId: id3 });
-    const parsed = JSON.parse(result.stdout);
-    const issue2 = Array.isArray(parsed) ? parsed[0] : parsed;
-    if (!issue2)
-      throw new Error(`bd show returned empty result for ${id3}`);
-    return issue2;
+    return parseDetailedIssue(JSON.parse(result.stdout), id3);
   };
   const mapState = (bd) => {
     const labelNames = (bd.labels ?? []).map((l) => normalizeState2(l));
@@ -290801,7 +291010,7 @@ var plugin2 = {
       ...config2.parkedStates ?? [],
       ...config2.terminalStates ?? []
     ].filter((s, i, arr) => arr.indexOf(s) === i);
-    const ops = createBeadsOps({
+    const ops = await createBeadsOps({
       beadsDir: config2.beadsDir,
       allStates
     });
@@ -290819,19 +291028,12 @@ var plugin2 = {
         return issues.filter((i) => normalized.has(normalizeState2(i.state)));
       },
       async fetchIssueStatesByIds(ids3) {
-        const results = await Promise.all(ids3.map(async (id3) => {
-          try {
-            const bd = await ops.viewIssue(id3);
-            return [
-              { id: bd.id, state: ops.mapState(bd) }
-            ];
-          } catch (e) {
-            if (e instanceof PluginNotFoundError)
-              return [];
-            throw e;
-          }
+        const wantedIds = new Set(ids3);
+        const allIssues = await ops.listAllIssues();
+        return allIssues.filter((issue2) => wantedIds.has(issue2.id)).map((issue2) => ({
+          id: issue2.id,
+          state: ops.mapState(issue2)
         }));
-        return results.flat();
       },
       fetchRunContext: (issueId, state) => ops.fetchRunContext(issueId, state)
     };
@@ -290839,9 +291041,9 @@ var plugin2 = {
 };
 var beads_default = plugin2;
 // packages/plot/src/tracker/github/index.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 var normalizeState3 = (s) => s.trim().toLowerCase();
 function mapGhFailure(error4, resourceId) {
   const message = error4 instanceof Error ? error4.message : String(error4);
@@ -290870,7 +291072,7 @@ function createGithubOps(config2) {
   const ghFields = "number,title,body,state,labels,url,createdAt,updatedAt";
   const runGh = async (args2, options5) => {
     try {
-      return await execFileAsync2("gh", args2, {
+      return await execFileAsync3("gh", args2, {
         maxBuffer: 50 * 1024 * 1024
       });
     } catch (error4) {
@@ -291156,11 +291358,11 @@ function adaptTrackerClient(plain) {
 var builtinTrackers = {
   beads: {
     definition: beads_default,
-    moduleDir: join34(dirname19(fileURLToPath6(import.meta.url)), "tracker", "beads")
+    moduleDir: join35(dirname20(fileURLToPath6(import.meta.url)), "tracker", "beads")
   },
   github: {
     definition: github_default,
-    moduleDir: join34(dirname19(fileURLToPath6(import.meta.url)), "tracker", "github")
+    moduleDir: join35(dirname20(fileURLToPath6(import.meta.url)), "tracker", "github")
   }
 };
 function buildPluginConfig(resolved) {
@@ -291178,11 +291380,11 @@ function syncGithubRepoEnv(resolved) {
   delete process.env["GITHUB_REPO"];
 }
 function discoverSkillPaths(moduleDir) {
-  const skillsDir = join34(moduleDir, "skills");
-  if (!existsSync24(skillsDir))
+  const skillsDir = join35(moduleDir, "skills");
+  if (!existsSync25(skillsDir))
     return [];
   try {
-    return readdirSync12(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join34(skillsDir, entry.name)).filter((dir) => existsSync24(join34(dir, "SKILL.md")));
+    return readdirSync12(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join35(skillsDir, entry.name)).filter((dir) => existsSync25(join35(dir, "SKILL.md")));
   } catch {
     return [];
   }
@@ -291225,7 +291427,7 @@ function resolvePlugin(resolved) {
       return yield* exports_Effect.die(new Error(`Tracker plugin "${kind}" does not export a valid default tracker plugin definition`));
     }
     const config2 = yield* resolveDefinitionConfig(definition, rawConfig);
-    const moduleDir = kind.startsWith("./") || kind.startsWith("../") || kind.startsWith("/") ? dirname19(resolve14(kind)) : undefined;
+    const moduleDir = kind.startsWith("./") || kind.startsWith("../") || kind.startsWith("/") ? dirname20(resolve14(kind)) : undefined;
     return yield* makeResolvedPlugin(definition, config2, moduleDir);
   });
 }
@@ -291379,7 +291581,7 @@ function postResponse(message) {
 function redirectProcessOutput(path14) {
   if (!path14)
     return;
-  mkdirSync9(dirname20(path14), { recursive: true });
+  mkdirSync9(dirname21(path14), { recursive: true });
   const stream8 = createWriteStream5(path14, { flags: "a" });
   const write4 = (chunk5) => {
     stream8.write(typeof chunk5 === "string" ? chunk5 : Buffer.from(chunk5));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plot-ai/linux-x64-musl",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "license": "MIT",
   "description": "orchestrate coding agents against an issue tracker",