@adriandmitroca/relay 0.0.2 → 0.1.0

package/README.md

@@ -2,6 +2,8 @@
 
 **Turn your backlog into pull requests — automatically.**
 
+![Relay Dashboard](screenshot.png)
+
 Relay connects to your existing project management tools, picks up tasks, and uses Claude Code to implement them in isolated git worktrees. You review the diff, click Accept, and a PR appears. That's it.
 
 No API keys to manage. No per-token billing. No workflow files to write. Relay runs locally on your machine using your Claude Code subscription (Pro, Max, or Team) and plugs directly into the tools you already use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adriandmitroca/relay",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Autonomous SWE agent — triage and fix issues from Sentry, Asana, Linear, and Jira with Claude",
   "module": "src/cli.ts",
   "type": "module",

package/src/cli.ts

@@ -2,6 +2,7 @@
 
 import { Daemon } from "./daemon.ts";
 import { setLogLevel } from "./utils/logger.ts";
+import { IssueDB, ConfigDB } from "./db.ts";
 import { join, dirname } from "node:path";
 import { unlinkSync } from "node:fs";
 import pkg from "../package.json" with { type: "json" };
@@ -21,8 +22,8 @@ function getFlag(name: string): string | undefined {
   return undefined;
 }
 
-function resolveConfigPath(): string {
-  return getFlag("config") ?? join(process.cwd(), "config.json");
+function dataDir(): string {
+  return join(process.env.HOME ?? "~", ".relay");
 }
 
 function getCommand(): string {
@@ -52,8 +53,10 @@ async function checkForUpdates() {
 }
 
 async function cmdStart() {
-  const configPath = resolveConfigPath();
-  const pidFile = join(process.cwd(), "relay.pid");
+  const dir = dataDir();
+  await Bun.$`mkdir -p ${dir}`.quiet();
+  const pidFile = join(dir, "relay.pid");
+  const dbPath = join(dir, "sqlite.db");
   const logLevel = getFlag("log-level");
   if (logLevel) setLogLevel(logLevel as "debug" | "info" | "warn" | "error");
 
@@ -74,7 +77,7 @@ async function cmdStart() {
   // Silent update check in background
   checkForUpdates().catch(() => {});
 
-  const daemon = new Daemon(configPath);
+  const daemon = new Daemon(dbPath);
 
   const cleanup = () => {
     try { unlinkSync(pidFile); } catch {}
@@ -91,7 +94,7 @@ async function cmdStart() {
 }
 
 async function cmdStop() {
-  const pidFile = join(process.cwd(), "relay.pid");
+  const pidFile = join(dataDir(), "relay.pid");
   const pid = Bun.file(pidFile);
   if (!(await pid.exists())) {
     console.log(`${YELLOW}No running daemon found.${RESET}`);
@@ -139,6 +142,83 @@ async function cmdUpdate() {
   }
 }
 
+async function cmdDoctor() {
+  let failures = 0;
+
+  function ok(msg: string) { console.log(`  ${GREEN}✓${RESET}  ${msg}`); }
+  function fail(msg: string, hint?: string) {
+    console.log(`  ${RED}✗${RESET}  ${msg}`);
+    if (hint) console.log(`       ${DIM}${hint}${RESET}`);
+    failures++;
+  }
+  function warn(msg: string, hint?: string) {
+    console.log(`  ${YELLOW}⚠${RESET}  ${msg}`);
+    if (hint) console.log(`       ${DIM}${hint}${RESET}`);
+  }
+
+  console.log(`\n${BOLD}relay doctor${RESET} — checking your setup\n`);
+
+  // 1. Bun
+  const bun = await Bun.$`bun --version`.quiet().nothrow();
+  if (bun.exitCode === 0) ok(`Bun ${bun.stdout.toString().trim()}`);
+  else fail("Bun not found", "Install at https://bun.sh");
+
+  // 2. Claude CLI
+  const claude = await Bun.$`claude --version`.quiet().nothrow();
+  if (claude.exitCode === 0) ok(`claude ${claude.stdout.toString().trim()}`);
+  else fail("claude CLI not found", "Install Claude Code: https://claude.ai/code");
+
+  // 3. GitHub CLI
+  const gh = await Bun.$`gh auth status`.quiet().nothrow();
+  if (gh.exitCode === 0) {
+    const line = gh.stderr.toString().split("\n").find(l => l.includes("Logged in"));
+    ok(`gh — ${line?.trim() ?? "authenticated"}`);
+  } else {
+    fail("gh not authenticated", "Run: gh auth login");
+  }
+
+  // 4. Data directory
+  const dir = dataDir();
+  const dirStat = await Bun.$`test -d ${dir}`.quiet().nothrow();
+  if (dirStat.exitCode === 0) ok(`~/.relay/ exists`);
+  else warn("~/.relay/ not found", "Will be created automatically on first start");
+
+  // 5. Database + config
+  const dbPath = join(dir, "sqlite.db");
+  const dbExists = await Bun.file(dbPath).exists();
+  if (dbExists) {
+    try {
+      const db = new IssueDB(dbPath);
+      const configDB = new ConfigDB(db.getDatabase());
+      if (configDB.hasConfig()) {
+        const workspaces = configDB.getWorkspaces();
+        const totalProjects = workspaces.reduce((n, ws) => n + configDB.getProjects(ws.id).length, 0);
+        ok(`database — ${workspaces.length} workspace${workspaces.length !== 1 ? "s" : ""}, ${totalProjects} project${totalProjects !== 1 ? "s" : ""}`);
+
+        // 6. Check repo paths for each project
+        for (const ws of workspaces) {
+          for (const proj of configDB.getProjects(ws.id)) {
+            const repoStat = await Bun.$`test -d ${join(proj.repo_path, ".git")}`.quiet().nothrow();
+            if (repoStat.exitCode === 0) ok(`${proj.key} — repo path valid`);
+            else fail(`${proj.key} — repo path not found: ${proj.repo_path}`, "Update the path in Settings");
+          }
+        }
+      } else {
+        warn("database exists but no config", "Open http://localhost:7842/setup to configure");
+      }
+    } catch {
+      fail("database exists but could not be read", "Try deleting ~/.relay/sqlite.db and reconfiguring");
+    }
+  } else {
+    warn("no database yet", "Run 'relay start' to create it");
+  }
+
+  console.log();
+  if (failures === 0) console.log(`${GREEN}All checks passed.${RESET}\n`);
+  else console.log(`${RED}${failures} check${failures !== 1 ? "s" : ""} failed.${RESET}\n`);
+  if (failures > 0) process.exit(1);
+}
+
 function showHelp() {
   console.log(`
 ${BOLD}Relay${RESET} v${VERSION} — Autonomous SWE agent
@@ -146,18 +226,18 @@ ${BOLD}Relay${RESET} v${VERSION} — Autonomous SWE agent
 ${BOLD}Usage:${RESET}
   relay start     Start the daemon (opens dashboard at localhost:7842)
   relay stop      Stop the daemon
+  relay doctor    Check your setup for problems
   relay update    Update to the latest version
   relay version   Show version
   relay help      Show this help
 
 ${BOLD}Options:${RESET}
-  --config <path>        Path to config.json (default: ./config.json)
   --log-level <level>    Override log level (debug/info/warn/error)
 
 ${BOLD}Getting started:${RESET}
-  bunx relayd             Try without installing
-  bun install -g relayd   Install globally
-  relay start             Start — configure via the setup wizard at localhost:7842
+  bunx @adriandmitroca/relay     Try without installing
+  bun install -g @adriandmitroca/relay   Install globally
+  relay start                    Start — configure via the setup wizard at localhost:7842
 `);
 }
 
@@ -171,6 +251,9 @@ switch (cmd) {
   case "stop":
     await cmdStop();
     break;
+  case "doctor":
+    await cmdDoctor();
+    break;
   case "update":
     await cmdUpdate();
     break;

package/src/config.ts

@@ -78,34 +78,6 @@ const DEFAULTS = {
   allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
 };
 
-export async function loadConfig(configPath: string): Promise<Config> {
-  const file = Bun.file(configPath);
-  if (!(await file.exists())) {
-    throw new Error(`Config not found at ${configPath}. Run 'relay init' to create one.`);
-  }
-
-  let raw: Record<string, unknown>;
-  try {
-    raw = await file.json();
-  } catch {
-    throw new Error(`Config at ${configPath} is not valid JSON. Check for syntax errors.`);
-  }
-
-  const config: Config = {
-    workspaces: (raw.workspaces as WorkspaceConfig[]) ?? [],
-    pollIntervalSeconds: (raw.pollIntervalSeconds as number) ?? DEFAULTS.pollIntervalSeconds,
-    maxConcurrency: (raw.maxConcurrency as number) ?? DEFAULTS.maxConcurrency,
-    claudeTimeout: (raw.claudeTimeout as number) ?? DEFAULTS.claudeTimeout,
-    triageTimeout: (raw.triageTimeout as number) ?? DEFAULTS.triageTimeout,
-    triage: (raw.triage as boolean) ?? DEFAULTS.triage,
-    logLevel: (raw.logLevel as Config["logLevel"]) ?? DEFAULTS.logLevel,
-    allowedTools: (raw.allowedTools as string[]) ?? DEFAULTS.allowedTools,
-  };
-
-  validate(config);
-  return config;
-}
-
 export function findProjectConfig(config: Config, projectKey: string): { workspace: WorkspaceConfig; project: ProjectConfig } | null {
   for (const ws of config.workspaces) {
     const project = ws.projects.find((p) => p.key === projectKey);

package/src/daemon.ts

@@ -1,4 +1,4 @@
-import { loadConfig, allProjects, findProjectConfig, type Config, type ProjectConfig, type WorkspaceConfig } from "./config.ts";
+import { allProjects, findProjectConfig, type Config, type ProjectConfig, type WorkspaceConfig } from "./config.ts";
 import { IssueDB, ConfigDB, type IssueRow, type IssueStatus } from "./db.ts";
 import { PriorityQueue } from "./queue.ts";
 import { SentryAdapter } from "./sources/sentry.ts";
@@ -44,33 +44,19 @@ export class Daemon {
   private queue!: PriorityQueue<PipelineItem>;
   private workspaces: Map<string, WorkspaceRuntime> = new Map();
   private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private configWatcher: ReturnType<typeof import("node:fs").watch> | null = null;
   private stopping = false;
-  private configPath: string;
+  private dbPath: string;
   private dashboard!: DashboardServer;
-  private baseDir: string;
 
-  constructor(configPath: string) {
-    this.configPath = configPath;
-    this.baseDir = dirname(configPath);
+  constructor(dbPath: string) {
+    this.dbPath = dbPath;
   }
 
   async start() {
     // Init DB
-    const dbPath = join(this.baseDir, "sqlite.db");
-    this.db = new IssueDB(dbPath);
+    this.db = new IssueDB(this.dbPath);
     this.configDB = new ConfigDB(this.db.getDatabase());
 
-    // Auto-import config.json if DB has no config
-    if (!this.configDB.hasConfig()) {
-      const configFile = Bun.file(this.configPath);
-      if (await configFile.exists()) {
-        const jsonConfig = await loadConfig(this.configPath);
-        this.configDB.importFromJson(jsonConfig);
-        logger.info("Auto-imported config.json into database");
-      }
-    }
-
     // Start dashboard (always — even without config for setup wizard)
     const isDev = process.env.DEV === "1";
     // Resolve dist/ relative to this source file so it works both in-repo and when
@@ -129,9 +115,6 @@ export class Daemon {
     // Start poll interval
     this.pollTimer = setInterval(() => this.poll(), this.config.pollIntervalSeconds * 1000);
 
-    // Watch config.json for hot reload (legacy support)
-    this.watchConfig();
-
     // Setup shutdown handlers
     this.setupShutdownHandlers();
 
@@ -223,11 +206,6 @@ export class Daemon {
     this.stopping = true;
     logger.info("Shutting down...");
 
-    if (this.configWatcher) {
-      this.configWatcher.close();
-      this.configWatcher = null;
-    }
-
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
@@ -330,58 +308,6 @@ export class Daemon {
     }
   }
 
-  private watchConfig() {
-    const { watch } = require("node:fs") as typeof import("node:fs");
-    let debounce: ReturnType<typeof setTimeout> | null = null;
-
-    this.configWatcher = watch(this.configPath, () => {
-      if (debounce) clearTimeout(debounce);
-      debounce = setTimeout(() => this.reloadConfig(), 500);
-    });
-
-    logger.debug("Watching config for changes", { path: this.configPath });
-  }
-
-  private async reloadConfig() {
-    try {
-      const newConfig = await loadConfig(this.configPath);
-
-      // Restart poll timer if interval changed
-      if (newConfig.pollIntervalSeconds !== this.config.pollIntervalSeconds) {
-        if (this.pollTimer) clearInterval(this.pollTimer);
-        this.pollTimer = setInterval(() => this.poll(), newConfig.pollIntervalSeconds * 1000);
-        logger.info("Poll interval updated", { seconds: newConfig.pollIntervalSeconds });
-      }
-
-      if (newConfig.logLevel !== this.config.logLevel) {
-        setLogLevel(newConfig.logLevel);
-        logger.info("Log level updated", { level: newConfig.logLevel });
-      }
-
-      // Reinit workspaces if workspace config changed
-      const oldWsJson = JSON.stringify(this.config.workspaces);
-      const newWsJson = JSON.stringify(newConfig.workspaces);
-      if (oldWsJson !== newWsJson) {
-        for (const ws of this.workspaces.values()) {
-          ws.telegram?.stopPolling();
-        }
-        this.workspaces.clear();
-        this.config = newConfig;
-        this.initWorkspaces();
-        logger.info("Workspaces reinitialized");
-      } else {
-        this.config = newConfig;
-      }
-
-      logger.info("Config reloaded");
-
-      // Trigger immediate poll after reload
-      await this.poll();
-    } catch (err) {
-      logger.error("Config reload failed, keeping current config", { error: String(err) });
-    }
-  }
-
   private async poll() {
     if (this.stopping) return;
 
@@ -1066,31 +992,46 @@ export class Daemon {
 function buildPRBody(row: IssueRow): string {
   const lines: string[] = [];
 
-  if (row.externalUrl) {
-    lines.push("## Source");
-    lines.push(row.externalUrl);
+  // Summary
+  lines.push("## Summary");
+  if (row.fixSummary) {
+    lines.push(row.fixSummary);
+  } else {
+    lines.push(`Automated fix for: ${row.title}`);
+  }
+  lines.push("");
+
+  // Context — triage plan if available
+  if (row.triagePlan) {
+    lines.push("## Context");
+    lines.push(row.triagePlan);
     lines.push("");
   }
 
-  lines.push("## Summary");
-  lines.push(row.fixSummary ?? "Automated changes.");
-  lines.push("");
+  // Source link
+  if (row.externalUrl) {
+    const sourceLabel = row.source.charAt(0).toUpperCase() + row.source.slice(1);
+    lines.push(`**${sourceLabel}:** ${row.externalUrl}`);
+    lines.push("");
+  }
 
+  // Test plan
   lines.push("## Test plan");
   lines.push("- [ ] Verify the changes resolve the issue");
-  lines.push("- [ ] Run existing tests");
-  lines.push("- [ ] Manual QA");
+  lines.push("- [ ] Existing tests pass");
+  lines.push("- [ ] Manual QA if applicable");
   lines.push("");
 
+  // Signature
   lines.push("---");
-  lines.push("🤖 Generated with [Claude Code](https://claude.com/claude-code) · Enhanced by [Relay](https://github.com/adriandmitroca/relay)");
+  lines.push("🤖 Generated with [Relay](https://github.com/adriandmitroca/relay) using [Claude Code](https://claude.com/claude-code)");
 
   return lines.join("\n");
 }
 
 // When run directly
 if (import.meta.main) {
-  const configPath = process.argv[2] || join(process.cwd(), "config.json");
-  const daemon = new Daemon(configPath);
+  const dbPath = process.argv[2] || join(process.env.HOME ?? "~", ".relay", "sqlite.db");
+  const daemon = new Daemon(dbPath);
   await daemon.start();
 }

package/src/db.ts

@@ -615,60 +615,6 @@ export class ConfigDB {
     return row.count > 0;
   }
 
-  importFromJson(config: Config): void {
-    this.db.exec("BEGIN TRANSACTION");
-    try {
-      // Import settings
-      const settingsMap: Record<string, string> = {
-        pollIntervalSeconds: String(config.pollIntervalSeconds),
-        maxConcurrency: String(config.maxConcurrency),
-        claudeTimeout: String(config.claudeTimeout),
-        triageTimeout: String(config.triageTimeout),
-        triage: String(config.triage),
-        logLevel: config.logLevel,
-        allowedTools: JSON.stringify(config.allowedTools),
-      };
-      this.updateSettings(settingsMap);
-
-      // Import workspaces
-      for (const ws of config.workspaces) {
-        const wsRow = this.createWorkspace(ws.key);
-
-        if (ws.telegram) {
-          this.upsertTelegramConfig(wsRow.id, ws.telegram.botToken, ws.telegram.chatId);
-        }
-
-        for (const proj of ws.projects) {
-          const projRow = this.createProject(wsRow.id, {
-            key: proj.key,
-            repoPath: proj.repoPath,
-            baseBranch: proj.baseBranch,
-            testCommand: proj.testCommand,
-          });
-
-          if (proj.sources.sentry) {
-            this.upsertSourceConfig(projRow.id, "sentry", proj.sources.sentry as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.asana) {
-            this.upsertSourceConfig(projRow.id, "asana", proj.sources.asana as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.linear) {
-            this.upsertSourceConfig(projRow.id, "linear", proj.sources.linear as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.jira) {
-            this.upsertSourceConfig(projRow.id, "jira", proj.sources.jira as unknown as Record<string, unknown>);
-          }
-        }
-      }
-
-      this.db.exec("COMMIT");
-      logger.info("Imported config from JSON to DB", { workspaces: config.workspaces.length });
-    } catch (err) {
-      this.db.exec("ROLLBACK");
-      throw err;
-    }
-  }
-
   toConfig(): Config {
     const settings = this.getSettings();
     const workspaces: WorkspaceConfig[] = [];