speexor 0.1.0

package/dist/chunk-B7WLHC4W.js

@@ -0,0 +1,666 @@
+import Debug from 'debug';
+import { execSync, spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { existsSync, mkdirSync, createWriteStream } from 'fs';
+import { join } from 'path';
+
+// src/plugins/agent/opencode.ts
+var debug = Debug("speexor:agent:opencode");
+var OpenCodeAgent = class {
+  name = "opencode-agent";
+  version = "0.1.0";
+  type = "agent";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug("OpenCode agent initialized");
+  }
+  async destroy() {
+    this.sessions.clear();
+    debug("OpenCode agent destroyed");
+  }
+  async spawn(task, runtime) {
+    const session = {
+      id: `oc-${task.id}-${Date.now()}`,
+      taskId: task.id,
+      provider: "opencode",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      runtimeSessionId: runtime.id
+    };
+    this.sessions.set(session.id, { task, runtime });
+    await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
+    debug(`OpenCode agent spawned: ${session.id}`);
+    return session;
+  }
+  async sendInput(sessionId, input) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    debug(`Input sent to session ${sessionId}: ${input.substring(0, 100)}...`);
+  }
+  async getStatus(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return "error";
+    return "running";
+  }
+  async kill(sessionId) {
+    this.sessions.delete(sessionId);
+    debug(`OpenCode agent killed: ${sessionId}`);
+  }
+};
+var debug2 = Debug("speexor:agent:claude-code");
+var ClaudeCodeAgent = class {
+  name = "claude-code-agent";
+  version = "0.1.0";
+  type = "agent";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug2("Claude Code agent initialized");
+  }
+  async destroy() {
+    this.sessions.clear();
+  }
+  async spawn(task, runtime) {
+    const session = {
+      id: `cc-${task.id}-${Date.now()}`,
+      taskId: task.id,
+      provider: "claude-code",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      runtimeSessionId: runtime.id
+    };
+    this.sessions.set(session.id, { task, runtime });
+    await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
+    debug2(`Claude Code agent spawned: ${session.id}`);
+    return session;
+  }
+  async sendInput(sessionId, input) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+  }
+  async getStatus(sessionId) {
+    return this.sessions.has(sessionId) ? "running" : "error";
+  }
+  async kill(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+var debug3 = Debug("speexor:agent:aider");
+var AiderAgent = class {
+  name = "aider-agent";
+  version = "0.1.0";
+  type = "agent";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug3("Aider agent initialized");
+  }
+  async destroy() {
+    this.sessions.clear();
+  }
+  async spawn(task, runtime) {
+    const session = {
+      id: `ai-${task.id}-${Date.now()}`,
+      taskId: task.id,
+      provider: "aider",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      runtimeSessionId: runtime.id
+    };
+    this.sessions.set(session.id, { task, runtime });
+    debug3(`Aider agent spawned: ${session.id}`);
+    return session;
+  }
+  async sendInput(sessionId, input) {
+  }
+  async getStatus(sessionId) {
+    return this.sessions.has(sessionId) ? "running" : "error";
+  }
+  async kill(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+var debug4 = Debug("speexor:agent:codex");
+var CodexAgent = class {
+  name = "codex-agent";
+  version = "0.1.0";
+  type = "agent";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug4("Codex agent initialized");
+  }
+  async destroy() {
+    this.sessions.clear();
+  }
+  async spawn(task, runtime) {
+    const session = {
+      id: `cx-${task.id}-${Date.now()}`,
+      taskId: task.id,
+      provider: "codex",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      runtimeSessionId: runtime.id
+    };
+    this.sessions.set(session.id, { task, runtime });
+    debug4(`Codex agent spawned: ${session.id}`);
+    return session;
+  }
+  async sendInput(sessionId, input) {
+  }
+  async getStatus(sessionId) {
+    return this.sessions.has(sessionId) ? "running" : "error";
+  }
+  async kill(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+var debug5 = Debug("speexor:runtime:tmux");
+var TmuxRuntime = class {
+  name = "tmux-runtime";
+  version = "0.1.0";
+  type = "runtime";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    try {
+      execSync("tmux -V", { stdio: "ignore" });
+      debug5("tmux available");
+    } catch {
+      console.warn("tmux not found \u2014 will fall back to process runtime");
+      throw new Error("tmux not available on this system");
+    }
+  }
+  async destroy() {
+    for (const [id] of this.sessions) {
+      await this.destroySession(id).catch(() => {
+      });
+    }
+  }
+  async createSession(worktreePath) {
+    const id = `tmux-${randomUUID().slice(0, 8)}`;
+    const sessionName = `speexor-${id}`;
+    try {
+      execSync(`tmux new-session -d -s ${sessionName} -c ${worktreePath}`, { stdio: "pipe" });
+    } catch (error) {
+      throw new Error(`Failed to create tmux session: ${error}`);
+    }
+    const session = {
+      id,
+      type: "tmux",
+      worktreePath,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.sessions.set(id, session);
+    debug5(`tmux session created: ${id} at ${worktreePath}`);
+    return session;
+  }
+  async destroySession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    try {
+      execSync(`tmux kill-session -t speexor-${sessionId}`, { stdio: "ignore" });
+    } catch {
+    }
+    this.sessions.delete(sessionId);
+    debug5(`tmux session destroyed: ${sessionId}`);
+  }
+  async sendInput(sessionId, input) {
+    const escaped = input.replace(/'/g, "'\\''");
+    execSync(`tmux send-keys -t speexor-${sessionId} '${escaped}' Enter`, { stdio: "ignore" });
+  }
+  async getOutput(sessionId) {
+    try {
+      return execSync(`tmux capture-pane -t speexor-${sessionId} -p`, { encoding: "utf-8" });
+    } catch {
+      return "";
+    }
+  }
+  getLiveStream(sessionId) {
+    throw new Error("Live stream not implemented for tmux");
+  }
+  async getStatus(sessionId) {
+    try {
+      execSync(`tmux has-session -t speexor-${sessionId}`, { stdio: "ignore" });
+      return "running";
+    } catch {
+      return "stopped";
+    }
+  }
+};
+var debug6 = Debug("speexor:runtime:process");
+var ProcessRuntime = class {
+  name = "process-runtime";
+  version = "0.1.0";
+  type = "runtime";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug6("Process runtime initialized");
+  }
+  async destroy() {
+    for (const [id] of this.sessions) {
+      await this.destroySession(id).catch(() => {
+      });
+    }
+  }
+  async createSession(worktreePath) {
+    const id = `proc-${randomUUID().slice(0, 8)}`;
+    const logsDir = join(process.cwd(), ".speexor", "logs");
+    if (!existsSync(logsDir)) {
+      mkdirSync(logsDir, { recursive: true });
+    }
+    const logStream = createWriteStream(join(logsDir, `${id}.log`), { flags: "a" });
+    const child = spawn(process.env.SHELL || "bash", [], {
+      cwd: worktreePath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, TERM: "xterm-256color" }
+    });
+    child.stdout?.on("data", (data) => {
+      logStream.write(`[stdout] ${data.toString()}`);
+    });
+    child.stderr?.on("data", (data) => {
+      logStream.write(`[stderr] ${data.toString()}`);
+    });
+    child.on("exit", (code) => {
+      logStream.write(`[exit] Process exited with code ${code}
+`);
+      logStream.end();
+    });
+    const session = {
+      id,
+      type: "process",
+      worktreePath,
+      pid: child.pid,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.sessions.set(id, { session, process: child });
+    debug6(`Process session created: ${id} (PID: ${child.pid})`);
+    return session;
+  }
+  async destroySession(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return;
+    entry.process.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        entry.process.kill("SIGKILL");
+      } catch {
+      }
+    }, 5e3);
+    this.sessions.delete(sessionId);
+    debug6(`Process session destroyed: ${sessionId}`);
+  }
+  async sendInput(sessionId, input) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) throw new Error(`Session ${sessionId} not found`);
+    entry.process.stdin?.write(`${input}
+`);
+  }
+  async getOutput(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return "";
+    return `Session ${sessionId} (PID: ${entry.process.pid})`;
+  }
+  getLiveStream(sessionId) {
+    throw new Error("Live stream not implemented for process runtime");
+  }
+  async getStatus(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return "stopped";
+    const exited = entry.process.exitCode !== null;
+    return exited ? "stopped" : "running";
+  }
+};
+var debug7 = Debug("speexor:workspace:git-worktree");
+var GitWorktreeWorkspace = class {
+  name = "git-worktree-workspace";
+  version = "0.1.0";
+  type = "workspace";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  worktreesDir = ".speexor/worktrees";
+  async initialize(context) {
+    this.context = context;
+    const dir = join(process.cwd(), this.worktreesDir);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    try {
+      execSync("git rev-parse --git-dir", { stdio: "ignore" });
+    } catch {
+      throw new Error("Not a git repository. Run `speexor start <repo>` first.");
+    }
+    debug7("Git worktree workspace initialized");
+  }
+  async destroy() {
+    const stale = await this.cleanupStale();
+    if (stale.length > 0) {
+      debug7(`Cleaned up ${stale.length} stale worktree(s)`);
+    }
+  }
+  async createWorktree(task) {
+    const branch = `speexor/${task.id}`;
+    const worktreePath = join(process.cwd(), this.worktreesDir, task.id);
+    try {
+      execSync(`git show-ref --verify --quiet refs/heads/${branch}`, { stdio: "ignore" });
+    } catch {
+      execSync(`git branch ${branch}`, { stdio: "pipe" });
+    }
+    try {
+      execSync(`git worktree add ${worktreePath} ${branch}`, { stdio: "pipe" });
+    } catch (error) {
+      throw new Error(`Failed to create worktree at ${worktreePath}: ${error}`);
+    }
+    const session = {
+      id: `wt-${task.id}-${randomUUID().slice(0, 8)}`,
+      taskId: task.id,
+      repository: task.repository,
+      branch,
+      path: worktreePath,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.sessions.set(session.id, session);
+    debug7(`Worktree created: ${branch} at ${worktreePath}`);
+    return session;
+  }
+  async removeWorktree(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    try {
+      execSync(`git worktree remove ${session.path}`, { stdio: "pipe" });
+    } catch {
+      try {
+        execSync(`git worktree remove --force ${session.path}`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    this.sessions.delete(sessionId);
+    debug7(`Worktree removed: ${sessionId}`);
+  }
+  getWorktreePath(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    return session.path;
+  }
+  async listActive() {
+    return Array.from(this.sessions.values());
+  }
+  async cleanupStale() {
+    const cleaned = [];
+    try {
+      const output = execSync("git worktree list --porcelain", { encoding: "utf-8" });
+      const lines = output.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          const path = line.slice(9).trim();
+          if (path.includes(this.worktreesDir)) {
+            const isActive = Array.from(this.sessions.values()).some((s) => s.path === path);
+            if (!isActive && existsSync(path)) {
+              try {
+                execSync(`git worktree remove --force "${path}"`, { stdio: "pipe" });
+                cleaned.push(path);
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return cleaned;
+  }
+};
+var debug8 = Debug("speexor:tracker:github");
+var GitHubTracker = class {
+  name = "github-tracker";
+  version = "0.1.0";
+  type = "tracker";
+  context;
+  handlers = [];
+  async initialize(context) {
+    this.context = context;
+    try {
+      execSync("gh --version", { stdio: "ignore" });
+      debug8("GitHub CLI available");
+    } catch {
+      throw new Error("GitHub CLI (gh) not found. Install from https://cli.github.com/");
+    }
+  }
+  async destroy() {
+    this.handlers = [];
+  }
+  async fetchIssues(filter) {
+    const state = filter?.state ?? "open";
+    const labels = filter?.labels?.length ? `--label "${filter.labels.join(",")}"` : "";
+    const limit = filter?.limit ?? 30;
+    try {
+      const output = execSync(
+        `gh issue list --state ${state} ${labels} --limit ${limit} --json number,title,body,state,labels,url,createdAt,updatedAt`,
+        { encoding: "utf-8" }
+      );
+      const issues = JSON.parse(output).map((i) => ({
+        id: String(i.number),
+        title: i.title,
+        description: i.body ?? "",
+        state: i.state,
+        labels: i.labels?.map((l) => l.name) ?? [],
+        url: i.url,
+        createdAt: new Date(i.createdAt),
+        updatedAt: new Date(i.updatedAt)
+      }));
+      return issues;
+    } catch (error) {
+      debug8("Failed to fetch issues:", error);
+      return [];
+    }
+  }
+  async getIssue(id) {
+    try {
+      const output = execSync(`gh issue view ${id} --json number,title,body,state,labels,url,createdAt,updatedAt`, { encoding: "utf-8" });
+      const i = JSON.parse(output);
+      return {
+        id: String(i.number),
+        title: i.title,
+        description: i.body ?? "",
+        state: i.state,
+        labels: i.labels?.map((l) => l.name) ?? [],
+        url: i.url,
+        createdAt: new Date(i.createdAt),
+        updatedAt: new Date(i.updatedAt)
+      };
+    } catch {
+      return null;
+    }
+  }
+  onEvent(handler) {
+    this.handlers.push(handler);
+  }
+  emit(event) {
+    for (const handler of this.handlers) {
+      handler(event);
+    }
+  }
+};
+var debug9 = Debug("speexor:scm:github");
+var GitHubSCM = class {
+  name = "github-scm";
+  version = "0.1.0";
+  type = "scm";
+  context;
+  handlers = [];
+  async initialize(context) {
+    this.context = context;
+    try {
+      execSync("gh --version", { stdio: "ignore" });
+      debug9("GitHub CLI available");
+    } catch {
+      throw new Error("GitHub CLI (gh) not found");
+    }
+  }
+  async destroy() {
+    this.handlers = [];
+  }
+  async createBranch(baseBranch, newBranch) {
+    execSync(`git fetch origin ${baseBranch}`, { stdio: "pipe" });
+    execSync(`git checkout -b ${newBranch} origin/${baseBranch}`, { stdio: "pipe" });
+  }
+  async commitAndPush(branch, message) {
+    execSync("git add -A", { stdio: "pipe" });
+    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: "pipe" });
+    execSync(`git push origin ${branch}`, { stdio: "pipe" });
+    const sha = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+    return sha;
+  }
+  async createPullRequest(title, description, head, base) {
+    const escapedBody = description.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+    const output = execSync(
+      `gh pr create --title "${title}" --body "${escapedBody}" --head ${head} --base ${base} --json number,title,url,state,headRefName,baseRefName,createdAt`,
+      { encoding: "utf-8" }
+    );
+    const pr = JSON.parse(output);
+    return {
+      id: String(pr.number),
+      url: pr.url,
+      title: pr.title,
+      state: pr.state,
+      headBranch: pr.headRefName,
+      baseBranch: pr.baseRefName,
+      createdAt: new Date(pr.createdAt)
+    };
+  }
+  async getPRStatus(prId) {
+    const output = execSync(
+      `gh pr view ${prId} --json number,state,mergeable,reviews,statusCheckRollup --jq '{state,mergeable,reviews,checks: .statusCheckRollup}'`,
+      { encoding: "utf-8" }
+    );
+    const data = JSON.parse(output);
+    return {
+      id: prId,
+      state: data.state,
+      mergeable: data.mergeable === "MERGEABLE",
+      ciStatus: this.determineCIStatus(data.checks),
+      reviewStatus: this.determineReviewStatus(data.reviews)
+    };
+  }
+  async getPRComments(prId) {
+    const output = execSync(
+      `gh pr view ${prId} --json comments --jq '.comments[] | {id: .id, author: .author.name, body: .body, createdAt: .createdAt}'`,
+      { encoding: "utf-8" }
+    );
+    const lines = output.trim().split("\n");
+    return lines.filter((l) => l.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((c) => c !== null);
+  }
+  async getCIRuns(prId) {
+    const output = execSync(
+      `gh pr view ${prId} --json statusCheckRollup --jq '.statusCheckRollup[] | {id: .databaseId, name: .name, status: .status, conclusion: .conclusion, url: .detailsUrl}'`,
+      { encoding: "utf-8" }
+    );
+    const lines = output.trim().split("\n");
+    return lines.filter((l) => l.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((c) => c !== null);
+  }
+  async mergePR(prId, method = "squash") {
+    execSync(`gh pr merge ${prId} --${method}`, { stdio: "pipe" });
+  }
+  onEvent(handler) {
+    this.handlers.push(handler);
+  }
+  determineCIStatus(checks) {
+    if (!checks || checks.length === 0) return "unknown";
+    const allPassed = checks.every((c) => c.conclusion === "success");
+    const anyFailed = checks.some((c) => c.conclusion === "failure" || c.conclusion === "cancelled");
+    const anyPending = checks.some((c) => c.status === "in_progress" || c.status === "queued");
+    if (anyFailed) return "failing";
+    if (anyPending) return "pending";
+    if (allPassed) return "passing";
+    return "unknown";
+  }
+  determineReviewStatus(reviews) {
+    if (!reviews || reviews.length === 0) return "none";
+    const latestState = reviews[reviews.length - 1]?.state;
+    if (latestState === "APPROVED") return "approved";
+    if (latestState === "CHANGES_REQUESTED") return "changes-requested";
+    if (latestState === "PENDING") return "pending";
+    return "none";
+  }
+};
+var debug10 = Debug("speexor:notifier:desktop");
+var DesktopNotifier = class {
+  name = "desktop-notifier";
+  version = "0.1.0";
+  type = "notifier";
+  async initialize(_context) {
+    debug10("Desktop notifier initialized");
+  }
+  async destroy() {
+  }
+  async notify(level, title, message) {
+    const platform = process.platform;
+    try {
+      if (platform === "darwin") {
+        const icon = level === "error" ? "\u26A0\uFE0F" : level === "success" ? "\u2705" : level === "warn" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+        execSync(
+          `osascript -e 'display notification "${message.replace(/"/g, '\\"')}" with title "${icon} ${title.replace(/"/g, '\\"')}"'`,
+          { stdio: "ignore" }
+        );
+      } else if (platform === "win32") {
+        const icon = level === "error" ? "Warning" : "Information";
+        execSync(`powershell -c "New-BurntToastNotification -Text '${title}', '${message}'"`, { stdio: "ignore" });
+      } else if (platform === "linux") {
+        execSync(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
+      }
+      debug10(`Desktop notification: ${title} - ${message}`);
+    } catch (error) {
+      debug10(`Failed to send notification: ${error}`);
+    }
+  }
+};
+
+// src/plugins/index.ts
+function loadAllPlugins() {
+  const plugins = [
+    // Agent adapters
+    new OpenCodeAgent(),
+    new ClaudeCodeAgent(),
+    new AiderAgent(),
+    new CodexAgent(),
+    // Runtime
+    new TmuxRuntime(),
+    new ProcessRuntime(),
+    // Workspace
+    new GitWorktreeWorkspace(),
+    // Tracker
+    new GitHubTracker(),
+    // SCM
+    new GitHubSCM(),
+    // Notifier
+    new DesktopNotifier()
+  ];
+  return plugins;
+}
+function loadPluginByType(type) {
+  return loadAllPlugins().find((p) => p.type === type);
+}
+
+export { loadAllPlugins, loadPluginByType };
+//# sourceMappingURL=chunk-B7WLHC4W.js.map
+//# sourceMappingURL=chunk-B7WLHC4W.js.map