@prsense/cli 0.1.0

package/src/commands/daemon.ts

@@ -0,0 +1,146 @@
+// apps/cli/src/commands/daemon/index.ts
+import { Command } from "commander";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import http from "node:http";
+
+const STATE_DIR = path.join(os.homedir(), ".local", "state", "prsense");
+const PID_FILE = path.join(STATE_DIR, "daemon.pid");
+const DAEMON_PORT = 3000;
+
+function ensureStateDir() {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkHealth(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const req = http.get(
+      {
+        hostname: "127.0.0.1",
+        port: DAEMON_PORT,
+        path: "/health",
+        timeout: 1000,
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+      },
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+const daemonCommand = new Command("daemon").description(
+  "Manage the PRsense daemon",
+);
+
+daemonCommand
+  .command("start")
+  .option("--foreground", "Run in foreground")
+  .action(async (opts) => {
+    ensureStateDir();
+
+    if (fs.existsSync(PID_FILE)) {
+      const pid = Number(fs.readFileSync(PID_FILE, "utf8"));
+
+      if (isProcessRunning(pid)) {
+        console.log("Daemon already running.");
+        return;
+      }
+
+      fs.unlinkSync(PID_FILE);
+    }
+
+    const require = createRequire(import.meta.url);
+    const daemonBin = require.resolve("@prsense/daemon/dist/index.js");
+
+    const logFile = path.join(STATE_DIR, "daemon.log");
+
+    const child = spawn(process.execPath, [daemonBin], {
+      detached: !opts.foreground,
+      cwd: process.cwd(),
+      stdio: opts.foreground
+        ? "inherit"
+        : ["ignore", fs.openSync(logFile, "a"), fs.openSync(logFile, "a")],
+    });
+
+    if (!opts.foreground) {
+      child.unref();
+      fs.writeFileSync(PID_FILE, String(child.pid));
+
+      // wait for daemon health
+      for (let i = 0; i < 15; i++) {
+        await new Promise((r) => setTimeout(r, 200));
+
+        if (await checkHealth()) {
+          console.log("Daemon started.");
+          return;
+        }
+
+        if (!isProcessRunning(child.pid!)) {
+          console.error("Daemon failed to start. See logs:");
+          console.error(logFile);
+          fs.unlinkSync(PID_FILE);
+          return;
+        }
+      }
+
+      console.error("Daemon did not become healthy.");
+      console.error("Check logs:", logFile);
+    }
+  });
+daemonCommand.command("stop").action(() => {
+  if (!fs.existsSync(PID_FILE)) {
+    console.log("Daemon not running.");
+    return;
+  }
+
+  const pid = Number(fs.readFileSync(PID_FILE, "utf8"));
+
+  try {
+    process.kill(pid, "SIGTERM");
+    fs.unlinkSync(PID_FILE);
+    console.log("Daemon stopped.");
+  } catch {
+    console.log("Failed to stop daemon.");
+  }
+});
+
+daemonCommand.command("status").action(async () => {
+  if (!fs.existsSync(PID_FILE)) {
+    console.log("Daemon not running.");
+    return;
+  }
+
+  const pid = Number(fs.readFileSync(PID_FILE, "utf8"));
+
+  if (!isProcessRunning(pid)) {
+    console.log("Daemon not running (stale PID).");
+    return;
+  }
+
+  const healthy = await checkHealth();
+
+  if (healthy) {
+    console.log("Daemon is running and healthy.");
+  } else {
+    console.log("Daemon process running but health check failed.");
+  }
+});
+
+export default daemonCommand;

package/src/commands/doctor.ts

@@ -0,0 +1,83 @@
+// apps/cli/src/commands/doctor.ts
+
+import { Command } from "commander";
+import { runDoctorWorkflow } from "@prsense/workflows";
+import { stdoutDoctorReporter, stdoutConfigReporter } from "@prsense/reporters";
+import { createPinoLogger, logEvent } from "@prsense/logging";
+import { createEventBus, CoreEvents } from "@prsense/core";
+import { resolveEnvironment } from "@prsense/config";
+
+import { createSpinnerRenderer } from "../ui/spinnerRenderer.js";
+import { eventToCliTask } from "../ui/eventToTask.js";
+
+const logLevel = (process.env.PRSENSE_LOG_LEVEL as any) ?? "warn";
+
+const logger = createPinoLogger({
+  level: logLevel,
+  pretty: true,
+});
+
+const renderer = createSpinnerRenderer(process.stdout);
+
+const eventBus = createEventBus((event) => {
+  // structured logs -> stderr
+  logEvent(logger, event);
+  // ui ->stdout
+  const mapped = eventToCliTask(event);
+  if (!mapped) return;
+  if (mapped.kind === "start") {
+    renderer.start(mapped.task);
+  } else if (mapped.kind === "update") {
+    renderer.update(mapped.task);
+  } else {
+    renderer.finish(mapped.task);
+  }
+});
+
+export const doctorCommand = new Command("doctor")
+  .description("Diagnose PRsense installation and environment")
+  .action(async () => {
+    eventBus.emit(CoreEvents.RunStarted, {
+      mode: "cli",
+      command: "doctor",
+    });
+
+    try {
+      const env = resolveEnvironment("cli", {
+        root: ".",
+        provider: "filesystem",
+      });
+      if (env.issues.length > 0) {
+        eventBus.emit(CoreEvents.RunFailed, {
+          reason: "invalid-config",
+        });
+
+        await stdoutConfigReporter.report({
+          issues: env.issues,
+        });
+        process.exit(1);
+      }
+      const result = await runDoctorWorkflow({ config: env.config, eventBus });
+
+      await stdoutDoctorReporter.report(result);
+
+      const hasFailures = result.checks.some((c) => c.status === "fail");
+
+      eventBus.emit(CoreEvents.RunFinished, {
+        outcome: hasFailures ? "failure" : "success",
+      });
+
+      process.exit(hasFailures ? 1 : 0);
+    } catch (err) {
+      eventBus.emit(CoreEvents.RunFailed, {
+        error: String(err),
+      });
+
+      renderer.finish({
+        id: "run",
+        label: "PRSense failed",
+        state: "failed",
+      });
+      return;
+    }
+  });

package/src/commands/index.ts

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import path from "node:path";
+
+import { runIndexWorkflow, listIndexedRepositories } from "@prsense/workflows";
+import { createPinoLogger, logEvent, LogLevel } from "@prsense/logging";
+import { createEventBus, CoreEvents, PRSENSE_VERSION } from "@prsense/core";
+import { resolveEnvironment } from "@prsense/config";
+
+import { createSpinnerRenderer } from "../ui/spinnerRenderer.js";
+import { eventToCliTask } from "../ui/eventToTask.js";
+import {
+  stdoutConfigReporter,
+  stdoutIndexedReposReporter,
+} from "@prsense/reporters";
+
+export const indexCommand = new Command("index")
+  .argument("[target]", "Path or GitHub/GitLab URL", ".")
+  .option("--force", "Rebuild the index from scratch")
+  .option("--dry-run", "Show what would be indexed without writing")
+  .option("--stats", "Print indexing statistics after completion")
+  .option("--chunk-size <n>", "Override chunk size (characters)")
+  .option("--list", "List indexed repositories")
+  .action(async (target, options) => {
+    try {
+      /* ------------------------------------------------- */
+      /* Load Config                                       */
+      /* ------------------------------------------------- */
+
+      const logger = createPinoLogger({
+        level: (process.env.PRSENSE_LOG_LEVEL ?? "warn") as LogLevel,
+        pretty: true,
+      });
+
+      const renderer = createSpinnerRenderer(process.stdout);
+
+      const eventBus = createEventBus((event) => {
+        logEvent(logger, event);
+
+        const mapped = eventToCliTask(event);
+        if (!mapped) return;
+
+        if (mapped.kind === "start") {
+          renderer.start(mapped.task);
+        } else if (mapped.kind === "update") {
+          renderer.update(mapped.task);
+        } else {
+          renderer.finish(mapped.task);
+        }
+      });
+
+      eventBus.emit(CoreEvents.RunStarted, {
+        mode: "cli",
+        command: "index",
+      });
+
+      /* ------------------------------------------------- */
+      /* Determine Repository Provider                     */
+      /* ------------------------------------------------- */
+
+      const isGithub = /github\.com/.test(target);
+      const isGitlab = /gitlab\.com/.test(target);
+
+      const repoProvider = isGithub
+        ? "github"
+        : isGitlab
+          ? "gitlab"
+          : "filesystem";
+
+      const repoRoot =
+        repoProvider === "filesystem" ? path.resolve(target) : target;
+
+      const env = resolveEnvironment("cli", {
+        root: repoRoot,
+        provider: repoProvider,
+      });
+      const resolved = env.config;
+
+      /* ------------------------------------------------- */
+      /* CLI Overrides (Before Resolve)                    */
+      /* ------------------------------------------------- */
+
+      if (options.list) {
+        const repos = await listIndexedRepositories(resolved);
+
+        await stdoutIndexedReposReporter.report(repos);
+        eventBus.emit(CoreEvents.RunFinished);
+
+        return;
+      }
+
+      if (env.issues.some((i) => i.level === "error")) {
+        eventBus.emit(CoreEvents.RunFailed, {
+          reason: "invalid-config",
+        });
+
+        await stdoutConfigReporter.report({ issues: env.issues });
+        process.exit(1);
+      }
+
+      /* ------------------------------------------------- */
+      /* Run Workflow                                      */
+      /* ------------------------------------------------- */
+
+      const result = await runIndexWorkflow({
+        config: resolved,
+        credentials: env.credentials,
+        target,
+        force: Boolean(options.force),
+        dryRun: Boolean(options.dryRun),
+        eventBus,
+        version: PRSENSE_VERSION,
+      });
+
+      eventBus.emit(CoreEvents.RunFinished, {
+        outcome: result.outcome,
+      });
+
+      /* ------------------------------------------------- */
+      /* Optional Stats                                    */
+      /* ------------------------------------------------- */
+
+      if (options.stats) {
+        const { chunksIndexed, commitSha, upToDate } = result.payload;
+
+        if (upToDate) {
+          console.log(`Index is up to date (commit ${commitSha ?? "unknown"})`);
+        } else {
+          console.log(
+            `Indexed ${chunksIndexed} chunks (commit ${commitSha ?? "unknown"})`,
+          );
+        }
+      }
+
+      process.exit(result.outcome === "failure" ? 1 : 0);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });

package/src/commands/review.ts

@@ -0,0 +1,153 @@
+// apps/cli/src/commands/review.ts
+import { Command } from "commander";
+import { runReviewWorkflow } from "@prsense/workflows";
+import { createPinoLogger, logEvent, LogLevel } from "@prsense/logging";
+import { createEventBus, CoreEvents } from "@prsense/core";
+import { resolveEnvironment } from "@prsense/config";
+
+import { createSpinnerRenderer } from "../ui/spinnerRenderer.js";
+import { eventToCliTask } from "../ui/eventToTask.js";
+import { stdoutConfigReporter } from "@prsense/reporters";
+import path from "node:path";
+import {
+  LocalGitDiffProvider,
+  GitHubPrDiffProvider,
+  GitLabMrDiffProvider,
+} from "@prsense/context";
+
+export const reviewCommand = new Command("review")
+  .argument("[target]", "Path to repository", ".")
+  .option("--base-branch <branch>", "Base branch to diff against")
+  .action(async (target, options) => {
+    const logger = createPinoLogger({
+      level: (process.env.PRSENSE_LOG_LEVEL ?? "warn") as LogLevel,
+      pretty: true,
+    });
+
+    const renderer = createSpinnerRenderer(process.stdout);
+
+    const eventBus = createEventBus((event) => {
+      logEvent(logger, event);
+
+      const mapped = eventToCliTask(event);
+      if (!mapped) return;
+
+      if (mapped.kind === "start") {
+        renderer.start(mapped.task);
+      } else if (mapped.kind === "update") {
+        renderer.update(mapped.task);
+      } else {
+        renderer.finish(mapped.task);
+      }
+    });
+
+    eventBus.emit(CoreEvents.RunStarted, {
+      mode: "cli",
+      command: "review",
+    });
+
+    try {
+      // -------------------------------------------------
+      // Load Config
+      // -------------------------------------------------
+
+      const repoRoot = path.resolve(target);
+
+      const githubPrMatch = target.match(
+        /github\.com\/([^\/]+)\/([^\/]+)\/pull\/(\d+)/,
+      );
+      const gitlabMrMatch = target.match(
+        /gitlab\.com\/([^\/]+)\/([^\/]+)\/-\/merge_requests\/(\d+)/,
+      );
+
+      const repoProvider = githubPrMatch
+        ? "github"
+        : gitlabMrMatch
+          ? "gitlab"
+          : "filesystem";
+
+      const env = resolveEnvironment("cli", {
+        root: repoRoot,
+        provider: repoProvider,
+      });
+
+      if (env.issues.some((i) => i.level === "error")) {
+        eventBus.emit(CoreEvents.RunFailed, {
+          reason: "invalid-config",
+        });
+
+        await stdoutConfigReporter.report({ issues: env.issues });
+        process.exit(1);
+      }
+
+      // -------------------------------------------------
+      // Create Diff Provider
+      // -------------------------------------------------
+
+      let diffProvider;
+
+      if (githubPrMatch) {
+        const [, owner, repo, prNumber] = githubPrMatch;
+
+        diffProvider = new GitHubPrDiffProvider(
+          owner,
+          repo.replace(".git", ""),
+          prNumber,
+        );
+      } else if (gitlabMrMatch) {
+        const [, group, project, mrNumber] = gitlabMrMatch;
+
+        diffProvider = new GitLabMrDiffProvider(
+          group,
+          project.replace(".git", ""),
+          mrNumber,
+        );
+      } else {
+        diffProvider = new LocalGitDiffProvider(repoRoot, options.baseBranch);
+      }
+
+      // -------------------------------------------------
+      // Run Review Workflow
+      // -------------------------------------------------
+
+      const result = await runReviewWorkflow({
+        config: env.config,
+        credentials: env.credentials,
+        diffProvider,
+        eventBus,
+      });
+
+      eventBus.emit(CoreEvents.RunFinished, {
+        outcome: result.outcome,
+      });
+
+      if (result.outcome === "failure") {
+        process.exit(1);
+      }
+
+      // -------------------------------------------------
+      // Print Signals
+      // -------------------------------------------------
+
+      for (const signal of result.payload.signals) {
+        console.log(`\n[${signal.severity.toUpperCase()}] ${signal.file}`);
+        console.log(signal.message);
+
+        if (signal.rationale) {
+          console.log(`  ↳ ${signal.rationale}`);
+        }
+
+        if (signal.suggestedFix) {
+          console.log(`  💡 ${signal.suggestedFix}`);
+        }
+      }
+
+      process.exit(0);
+    } catch (err) {
+      eventBus.emit(CoreEvents.RunFailed, {
+        error: String(err),
+      });
+
+      process.exit(1);
+    }
+  });

package/src/commands/setup.ts

@@ -0,0 +1,124 @@
+import { Command } from "commander";
+import { createPinoLogger, logEvent } from "@prsense/logging";
+import { createEventBus, CoreEvents } from "@prsense/core";
+
+import { createSpinnerRenderer } from "../ui/spinnerRenderer.js";
+import { eventToCliTask } from "../ui/eventToTask.js";
+import { stdoutConfigReporter } from "@prsense/reporters";
+
+import { runSetupWorkflow } from "@prsense/workflows";
+import type { Capability } from "@prsense/preflight";
+import { resolveEnvironment } from "@prsense/config";
+
+import {
+  postgresCapability,
+  pgVectorCapability,
+  dockerCapability,
+  schemaCapability,
+} from "@prsense/preflight";
+
+export const setupCommand = new Command("setup")
+  .description("Validate and optionally provision required infrastructure")
+  .action(async () => {
+    const logLevel = (process.env.PRSENSE_LOG_LEVEL as any) ?? "warn";
+
+    const logger = createPinoLogger({
+      level: logLevel,
+      pretty: true,
+    });
+
+    const renderer = createSpinnerRenderer(process.stdout);
+
+    const eventBus = createEventBus((event) => {
+      logEvent(logger, event);
+
+      const mapped = eventToCliTask(event);
+      if (!mapped) return;
+
+      if (mapped.kind === "start") {
+        renderer.start(mapped.task);
+      } else if (mapped.kind === "update") {
+        renderer.update(mapped.task);
+      } else {
+        renderer.finish(mapped.task);
+      }
+    });
+
+    eventBus.emit(CoreEvents.RunStarted, {
+      mode: "cli",
+      command: "setup",
+    });
+
+    try {
+      // -------------------------------------------------
+      // Load Config
+      // -------------------------------------------------
+
+      const cwd = process.cwd();
+      const env = resolveEnvironment("cli", {
+        root: cwd,
+        provider: "filesystem",
+      });
+
+      if (env.issues.length > 0) {
+        eventBus.emit(CoreEvents.RunFailed, {
+          reason: "invalid-config",
+        });
+
+        await stdoutConfigReporter.report({ issues: env.issues });
+        process.exit(1);
+      }
+
+      // -------------------------------------------------
+      // Capabilities
+      // -------------------------------------------------
+
+      const capabilities: Capability[] = [
+        dockerCapability,
+        postgresCapability,
+        pgVectorCapability,
+        schemaCapability,
+      ];
+
+      const result = await runSetupWorkflow({
+        capabilities,
+        ctx: {
+          config: env.config,
+          env: process.env,
+          cwd,
+        },
+        eventBus,
+      });
+
+      eventBus.emit(CoreEvents.RunFinished, {
+        outcome: result.outcome,
+      });
+
+      // -------------------------------------------------
+      // Human Summary
+      // -------------------------------------------------
+
+      console.log("\nSetup Summary:");
+
+      for (const step of result.steps) {
+        if (step.outcome === "applied") {
+          console.log(`✔ ${step.id} applied`);
+        } else if (step.outcome === "skipped") {
+          console.log(`• ${step.id} ready`);
+        } else {
+          console.log(`✖ ${step.id} failed`);
+          if (step.error) {
+            console.log(`  ↳ ${step.error}`);
+          }
+        }
+      }
+
+      process.exit(result.outcome === "failure" ? 1 : 0);
+    } catch (err) {
+      eventBus.emit(CoreEvents.RunFailed, {
+        error: String(err),
+      });
+
+      process.exit(1);
+    }
+  });

package/src/index.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { program } from "./program.js";
+
+program.parse(process.argv);

package/src/program.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { reviewCommand } from "./commands/review.js";
+import { indexCommand } from "./commands/index.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { setupCommand } from "./commands/setup.js";
+import daemonCommand from "./commands/daemon.js";
+import { PRSENSE_VERSION } from "@prsense/core";
+
+export const program = new Command()
+  .name("prsense")
+  .description("PRsense – signal-based pull request reviews")
+  .version(PRSENSE_VERSION);
+
+program.addCommand(reviewCommand);
+program.addCommand(indexCommand);
+program.addCommand(doctorCommand);
+program.addCommand(setupCommand);
+program.addCommand(daemonCommand);

package/src/shared/types.ts

@@ -0,0 +1,11 @@
+import { ReviewSignal } from "@prsense/core";
+
+export type CliReviewResult = {
+  signals: ReviewSignal[];
+  summary: {
+    total: number;
+    high: number;
+    medium: number;
+    low: number;
+  };
+};