@dreki-gg/pi-pr-canvas 1.6.0

package/extensions/pr-canvas/commands.ts

@@ -0,0 +1,174 @@
+import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { createPiAiChatFn } from './ai/pi-ai-adapter';
+import { createWsBridge, type WsBridge } from './server/ws-bridge';
+import { createServerManager, resolveAppDir, type ServerManager } from './server/manager';
+import { createMessageHandlers } from './server/handlers';
+
+const WS_PORT = 3001;
+const APP_PORT = 3000;
+
+export function registerPrCanvasCommands(pi: ExtensionAPI) {
+  let bridge: WsBridge | null = null;
+  let manager: ServerManager | null = null;
+
+  async function startServer(ctx: ExtensionCommandContext) {
+    // 1. Check gh auth
+    ctx.ui.setStatus('pr-canvas', '🔍 Checking gh CLI...');
+    try {
+      const authResult = await pi.exec('gh', ['auth', 'status']);
+      if (authResult.code !== 0) {
+        ctx.ui.notify(
+          `gh CLI not authenticated: ${authResult.stderr}\nRun \`gh auth login\` first.`,
+          'error',
+        );
+        ctx.ui.setStatus('pr-canvas', undefined);
+        return;
+      }
+    } catch {
+      ctx.ui.notify(
+        'gh CLI not found. Install from https://cli.github.com/ and run `gh auth login`.',
+        'error',
+      );
+      ctx.ui.setStatus('pr-canvas', undefined);
+      return;
+    }
+
+    // 2. Start WebSocket bridge
+    ctx.ui.setStatus('pr-canvas', '🔌 Starting WebSocket bridge...');
+    bridge = createWsBridge();
+    const aiChat = createPiAiChatFn(ctx, { thinkingLevel: pi.getThinkingLevel() });
+    if (!aiChat) {
+      ctx.ui.notify(
+        'PR Canvas AI unavailable: no active Pi model or credentials. Using deterministic summaries.',
+        'warning',
+      );
+    }
+    const handlers = createMessageHandlers((cmd, args) => pi.exec(cmd, args), aiChat);
+    bridge.onMessage(handlers);
+
+    try {
+      await bridge.start(WS_PORT);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.ui.notify(`Failed to start WebSocket bridge: ${msg}`, 'error');
+      ctx.ui.setStatus('pr-canvas', undefined);
+      bridge = null;
+      return;
+    }
+
+    // 3. Start SolidStart server
+    ctx.ui.setStatus('pr-canvas', '🚀 Starting PR Canvas server...');
+    const appDir = resolveAppDir();
+    manager = createServerManager(appDir);
+
+    try {
+      await manager.start({ port: APP_PORT, wsBridgeUrl: `ws://localhost:${WS_PORT}` });
+    } catch (err) {
+      const reason =
+        err instanceof Error
+          ? err.message
+          : err && typeof err === 'object' && 'reason' in err
+            ? (err as any).reason
+            : String(err);
+      ctx.ui.notify(`Failed to start server: ${reason}\nApp dir: ${appDir}`, 'error');
+      ctx.ui.setStatus('pr-canvas', undefined);
+      await bridge.stop();
+      bridge = null;
+      manager = null;
+      return;
+    }
+
+    // 4. Open browser
+    const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+    await pi.exec(openCmd, [`http://localhost:${APP_PORT}`]);
+
+    ctx.ui.setStatus('pr-canvas', `✅ Running on localhost:${APP_PORT}`);
+    ctx.ui.notify(`PR Canvas running at http://localhost:${APP_PORT}`, 'info');
+  }
+
+  async function stopServer(ctx: ExtensionCommandContext) {
+    ctx.ui.setStatus('pr-canvas', '⏹ Stopping...');
+
+    if (manager) {
+      await manager.stop();
+      manager = null;
+    }
+
+    if (bridge) {
+      await bridge.stop();
+      bridge = null;
+    }
+
+    ctx.ui.setStatus('pr-canvas', undefined);
+    ctx.ui.notify('PR Canvas stopped.', 'info');
+  }
+
+  pi.registerCommand('pr-canvas', {
+    description:
+      'Manage the PR Canvas server. Usage: /pr-canvas start | stop | open [number] | status',
+    handler: async (args, ctx) => {
+      const parts = (args?.trim() || '').split(/\s+/);
+      const subcommand = parts[0] || '';
+
+      switch (subcommand) {
+        case 'start': {
+          if (manager?.isRunning) {
+            ctx.ui.notify(
+              `PR Canvas is already running at http://localhost:${APP_PORT}`,
+              'warning',
+            );
+            return;
+          }
+          await startServer(ctx);
+          break;
+        }
+
+        case 'stop': {
+          if (!manager?.isRunning && !bridge?.isRunning) {
+            ctx.ui.notify('PR Canvas is not running.', 'warning');
+            return;
+          }
+          await stopServer(ctx);
+          break;
+        }
+
+        case 'open': {
+          if (!manager?.isRunning) {
+            ctx.ui.notify('PR Canvas is not running. Run /pr-canvas start first.', 'warning');
+            return;
+          }
+          const prNumber = parts[1];
+          const url = prNumber
+            ? `http://localhost:${APP_PORT}/pr/${prNumber}`
+            : `http://localhost:${APP_PORT}`;
+          const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+          await pi.exec(openCmd, [url]);
+          ctx.ui.notify(`Opened ${url}`, 'info');
+          break;
+        }
+
+        case 'status': {
+          const serverStatus = manager?.isRunning
+            ? `✅ Server: http://localhost:${APP_PORT}`
+            : '⏹ Server: stopped';
+          const bridgeStatus = bridge?.isRunning
+            ? `✅ Bridge: ws://localhost:${WS_PORT}`
+            : '⏹ Bridge: stopped';
+          ctx.ui.notify(`${serverStatus}\n${bridgeStatus}`, 'info');
+          break;
+        }
+
+        default:
+          ctx.ui.notify('Usage: /pr-canvas start | stop | open [number] | status', 'warning');
+      }
+    },
+  });
+
+  // Cleanup on session shutdown
+  pi.on('session_shutdown', async () => {
+    if (manager?.isRunning) await manager.stop();
+    if (bridge?.isRunning) await bridge.stop();
+    manager = null;
+    bridge = null;
+  });
+}

package/extensions/pr-canvas/effect/errors.ts

@@ -0,0 +1,50 @@
+import { Data } from 'effect';
+
+// ── GitHub CLI errors ──────────────────────────────────────────────────
+
+/** A `gh` CLI command failed (non-zero exit code) */
+export class GhCliError extends Data.TaggedError('GhCliError')<{
+  readonly command: string;
+  readonly stderr: string;
+}> {}
+
+/** The user is not authenticated with `gh auth` */
+export class GhAuthError extends Data.TaggedError('GhAuthError')<{
+  readonly message: string;
+}> {}
+
+/** The requested PR was not found */
+export class GhNotFoundError extends Data.TaggedError('GhNotFoundError')<{
+  readonly prRef: string;
+}> {}
+
+// ── WebSocket bridge errors ────────────────────────────────────────────
+
+/** The WebSocket bridge server failed to start or encountered a fatal error */
+export class WsBridgeError extends Data.TaggedError('WsBridgeError')<{
+  readonly reason: string;
+}> {}
+
+/** A WebSocket client connection failed or was dropped unexpectedly */
+export class WsConnectionError extends Data.TaggedError('WsConnectionError')<{
+  readonly reason: string;
+}> {}
+
+// ── Server manager errors ──────────────────────────────────────────────
+
+/** The SolidStart server process failed to start or become ready */
+export class ServerStartError extends Data.TaggedError('ServerStartError')<{
+  readonly reason: string;
+}> {}
+
+/** The SolidStart server process failed to stop cleanly */
+export class ServerStopError extends Data.TaggedError('ServerStopError')<{
+  readonly reason: string;
+}> {}
+
+// ── AI service errors ──────────────────────────────────────────────────
+
+/** The AI chat request failed (model unavailable, timeout, etc.) */
+export class AiChatError extends Data.TaggedError('AiChatError')<{
+  readonly message: string;
+}> {}

package/extensions/pr-canvas/effect/schemas.ts

@@ -0,0 +1,105 @@
+import { Schema } from 'effect';
+
+// ── GitHub CLI output schemas ──────────────────────────────────────────
+
+export const PrAuthorSchema = Schema.Struct({
+  login: Schema.String,
+});
+
+export const PrLabelSchema = Schema.Struct({
+  name: Schema.String,
+  color: Schema.String,
+});
+
+export const PrOverviewSchema = Schema.Struct({
+  number: Schema.Number,
+  title: Schema.String,
+  body: Schema.optionalWith(Schema.String, { default: () => '' }),
+  author: PrAuthorSchema,
+  state: Schema.String,
+  labels: Schema.Array(PrLabelSchema),
+  baseRefName: Schema.String,
+  headRefName: Schema.String,
+  url: Schema.String,
+  additions: Schema.Number,
+  deletions: Schema.Number,
+  createdAt: Schema.String,
+  updatedAt: Schema.String,
+});
+export type PrOverview = typeof PrOverviewSchema.Type;
+
+export const PrReviewRequestSchema = Schema.Struct({
+  login: Schema.optionalWith(Schema.String, { default: () => 'unknown' }),
+});
+
+export const PrCheckSchema = Schema.Struct({
+  name: Schema.optionalWith(Schema.String, { default: () => '' }),
+  state: Schema.optionalWith(Schema.String, { default: () => 'PENDING' }),
+  description: Schema.optionalWith(Schema.String, { default: () => '' }),
+  detailsUrl: Schema.optionalWith(Schema.String, { default: () => '' }),
+});
+
+export const PrCommentSchema = Schema.Struct({
+  author: PrAuthorSchema,
+  body: Schema.optionalWith(Schema.String, { default: () => '' }),
+  createdAt: Schema.optionalWith(Schema.String, { default: () => '' }),
+  path: Schema.optional(Schema.String),
+  line: Schema.optional(Schema.Number),
+});
+
+export const PrReviewSchema = Schema.Struct({
+  author: PrAuthorSchema,
+  state: Schema.optionalWith(Schema.String, { default: () => 'COMMENTED' }),
+  body: Schema.optionalWith(Schema.String, { default: () => '' }),
+  createdAt: Schema.optionalWith(Schema.String, { default: () => '' }),
+  comments: Schema.optionalWith(Schema.Array(PrCommentSchema), { default: () => [] }),
+});
+
+/** Schema for `gh pr list --json ...` output items */
+export const PrListItemSchema = Schema.Struct({
+  number: Schema.Number,
+  title: Schema.String,
+  author: PrAuthorSchema,
+  state: Schema.String,
+  url: Schema.String,
+  additions: Schema.optionalWith(Schema.Number, { default: () => 0 }),
+  deletions: Schema.optionalWith(Schema.Number, { default: () => 0 }),
+  createdAt: Schema.optionalWith(Schema.String, { default: () => '' }),
+});
+export type PrListItem = typeof PrListItemSchema.Type;
+
+// ── WebSocket message schemas ──────────────────────────────────────────
+
+export const WsMessageToServer = Schema.Union(
+  Schema.Struct({ type: Schema.Literal('pr:list') }),
+  Schema.Struct({ type: Schema.Literal('pr:data'), number: Schema.Number }),
+  Schema.Struct({ type: Schema.Literal('pr:subscribe'), number: Schema.Number }),
+  Schema.Struct({
+    type: Schema.Literal('ai:chat'),
+    message: Schema.String,
+    prNumber: Schema.Number,
+  }),
+);
+export type WsMessageToServer = typeof WsMessageToServer.Type;
+
+export const WsMessageFromServer = Schema.Union(
+  Schema.Struct({ type: Schema.Literal('pr:list:result'), prs: Schema.Array(PrListItemSchema) }),
+  Schema.Struct({
+    type: Schema.Literal('pr:data:result'),
+    number: Schema.Number,
+    // Data is passed as opaque JSON — validated at the boundary, not here
+    data: Schema.Unknown,
+    rawDiff: Schema.String,
+    mindMap: Schema.Unknown,
+    aiSummary: Schema.Unknown,
+  }),
+  Schema.Struct({ type: Schema.Literal('pr:update'), number: Schema.Number, data: Schema.Unknown }),
+  Schema.Struct({ type: Schema.Literal('ai:chat:response'), message: Schema.String }),
+  Schema.Struct({
+    type: Schema.Literal('ai:chat:stream'),
+    chunk: Schema.String,
+    done: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+  }),
+  Schema.Struct({ type: Schema.Literal('error'), message: Schema.String }),
+);
+export type WsMessageFromServer = typeof WsMessageFromServer.Type;

package/extensions/pr-canvas/effect/services.ts

@@ -0,0 +1,23 @@
+import { Context, Effect } from 'effect';
+import type { GhCliError, AiChatError } from './errors';
+
+// ── ExecService ────────────────────────────────────────────────────────
+/** Shell command execution — wraps pi.exec() */
+export class ExecService extends Context.Tag('ExecService')<
+  ExecService,
+  {
+    readonly exec: (
+      command: string,
+      args: string[],
+    ) => Effect.Effect<{ stdout: string; stderr: string; code: number }, GhCliError>;
+  }
+>() {}
+
+// ── AiService ──────────────────────────────────────────────────────────
+/** AI model access — wraps pi.sendMessage() */
+export class AiService extends Context.Tag('AiService')<
+  AiService,
+  {
+    readonly chat: (message: string, context: string) => Effect.Effect<string, AiChatError>;
+  }
+>() {}

package/extensions/pr-canvas/github/client.ts

@@ -0,0 +1,132 @@
+import { Effect, Schema } from 'effect';
+import { ExecService } from '../effect/services';
+import { GhCliError } from '../effect/errors';
+import {
+  PrOverviewSchema,
+  PrCheckSchema,
+  PrCommentSchema,
+  PrReviewSchema,
+  PrListItemSchema,
+} from '../effect/schemas';
+import type { PrOverview, PrCheck, PrComment, PrReview } from './types';
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+const PR_VIEW_FIELDS = [
+  'number',
+  'title',
+  'body',
+  'author',
+  'state',
+  'labels',
+  'reviewRequests',
+  'baseRefName',
+  'headRefName',
+  'url',
+  'additions',
+  'deletions',
+  'createdAt',
+  'updatedAt',
+  'comments',
+  'reviews',
+].join(',');
+
+/** Run a `gh` command and return stdout, failing with GhCliError on non-zero exit */
+const gh = (args: string[]) =>
+  Effect.gen(function* () {
+    const { exec } = yield* ExecService;
+    const result = yield* exec('gh', args);
+    if (result.code !== 0) {
+      return yield* Effect.fail(
+        new GhCliError({ command: `gh ${args.join(' ')}`, stderr: result.stderr }),
+      );
+    }
+    return result.stdout;
+  });
+
+/** Parse JSON string, mapping errors to GhCliError */
+const parseJson = (json: string, command: string) =>
+  Effect.try({
+    try: () => JSON.parse(json),
+    catch: () => new GhCliError({ command, stderr: 'Invalid JSON response' }),
+  });
+
+// ── Public API ─────────────────────────────────────────────────────────
+
+/** Fetch PR overview metadata */
+export const fetchOverview = (prRef: string) =>
+  Effect.gen(function* () {
+    const json = yield* gh(['pr', 'view', prRef, '--json', PR_VIEW_FIELDS]);
+    const raw = yield* parseJson(json, 'pr view');
+    const overview = yield* Schema.decode(PrOverviewSchema)(raw).pipe(
+      Effect.catchTag('ParseError', (e) =>
+        Effect.fail(new GhCliError({ command: 'pr view', stderr: e.message })),
+      ),
+    );
+
+    // Map reviewRequests to our reviewers format
+    const reviewers = (raw.reviewRequests ?? []).map((r: { login?: string }) => ({
+      login: r.login ?? 'unknown',
+    }));
+
+    return { ...overview, reviewers } as PrOverview & { reviewers: Array<{ login: string }> };
+  });
+
+/** Fetch the raw unified diff */
+export const fetchDiff = (prRef: string) => gh(['pr', 'diff', prRef]);
+
+/** Fetch CI checks */
+export const fetchChecks = (prRef: string) =>
+  Effect.gen(function* () {
+    const json = yield* gh(['pr', 'checks', prRef, '--json', 'name,state,description,detailsUrl']);
+    const raw = yield* parseJson(json, 'pr checks');
+    if (!Array.isArray(raw)) return [] as PrCheck[];
+    return yield* Schema.decode(Schema.Array(PrCheckSchema))(raw).pipe(
+      Effect.catchTag('ParseError', () => Effect.succeed([] as PrCheck[])),
+    );
+  });
+
+/** Fetch comments and reviews */
+export const fetchCommentsAndReviews = (prRef: string) =>
+  Effect.gen(function* () {
+    const json = yield* gh(['pr', 'view', prRef, '--json', 'comments,reviews']);
+    const raw = yield* parseJson(json, 'pr view comments');
+
+    const comments = yield* Schema.decode(Schema.Array(PrCommentSchema))(raw.comments ?? []).pipe(
+      Effect.catchTag('ParseError', () => Effect.succeed([] as PrComment[])),
+    );
+
+    // GitHub returns `submittedAt` for reviews (not `createdAt`); normalize it.
+    const normalizedReviews = (raw.reviews ?? []).map((r: Record<string, unknown>) => ({
+      ...r,
+      createdAt: r.createdAt ?? r.submittedAt ?? '',
+    }));
+    const reviews = yield* Schema.decode(Schema.Array(PrReviewSchema))(normalizedReviews).pipe(
+      Effect.catchTag('ParseError', () => Effect.succeed([] as PrReview[])),
+    );
+
+    return { comments, reviews };
+  });
+
+/** List open PRs for the current repo */
+export const fetchPrList = Effect.gen(function* () {
+  const json = yield* gh([
+    'pr',
+    'list',
+    '--json',
+    'number,title,author,state,url,additions,deletions,createdAt',
+  ]);
+  const raw = yield* parseJson(json, 'pr list');
+  if (!Array.isArray(raw)) return [];
+  return yield* Schema.decode(Schema.Array(PrListItemSchema))(raw).pipe(
+    Effect.catchTag('ParseError', () => Effect.succeed([])),
+  );
+});
+
+// ── exec type ──────────────────────────────────────────────────────────
+/** Minimal exec interface matching ExtensionAPI.exec() */
+export type ExecFn = (
+  command: string,
+  args: string[],
+  options?: { cwd?: string },
+) => Promise<{ stdout: string; stderr: string; code: number }>;

package/extensions/pr-canvas/github/parser.ts

@@ -0,0 +1,73 @@
+import type { PrFile } from './types';
+
+/**
+ * Parse a unified diff (output of `gh pr diff`) into structured file entries.
+ */
+export function parseDiff(rawDiff: string): PrFile[] {
+  if (!rawDiff.trim()) return [];
+
+  const files: PrFile[] = [];
+
+  // Split on `diff --git` boundaries, keeping each file's full diff block
+  const blocks = rawDiff.split(/^diff --git /m).filter((b) => b.trim());
+
+  for (const block of blocks) {
+    const fullBlock = `diff --git ${block}`;
+    const file = parseFileBlock(fullBlock);
+    if (file) files.push(file);
+  }
+
+  return files;
+}
+
+function parseFileBlock(block: string): PrFile | null {
+  // Extract file path from "diff --git a/path b/path"
+  const headerMatch = block.match(/^diff --git a\/(.+?) b\/(.+)/m);
+  if (!headerMatch) return null;
+
+  const path = headerMatch[2];
+  const status = detectStatus(block);
+  const isBinary = /^Binary files /m.test(block);
+
+  let additions = 0;
+  let deletions = 0;
+
+  if (!isBinary) {
+    // Count + and - lines in the patch (skip --- and +++ header lines)
+    const lines = block.split('\n');
+    let inHunk = false;
+
+    for (const line of lines) {
+      if (line.startsWith('@@')) {
+        inHunk = true;
+        continue;
+      }
+      if (!inHunk) continue;
+
+      if (line.startsWith('+') && !line.startsWith('+++')) {
+        additions++;
+      } else if (line.startsWith('-') && !line.startsWith('---')) {
+        deletions++;
+      }
+    }
+  }
+
+  // Build the patch content (everything after the diff --git header line)
+  const patch = isBinary ? `Binary files differ` : extractPatch(block);
+
+  return { path, status, additions, deletions, patch };
+}
+
+function detectStatus(block: string): PrFile['status'] {
+  if (/^new file mode/m.test(block)) return 'added';
+  if (/^deleted file mode/m.test(block)) return 'deleted';
+  if (/^rename from /m.test(block)) return 'renamed';
+  return 'modified';
+}
+
+function extractPatch(block: string): string {
+  // Return from the first @@ hunk header onwards
+  const hunkStart = block.indexOf('@@');
+  if (hunkStart === -1) return block;
+  return block.slice(hunkStart);
+}

package/extensions/pr-canvas/github/types.ts

@@ -0,0 +1,66 @@
+/** Overview metadata from `gh pr view --json ...` */
+export interface PrOverview {
+  number: number;
+  title: string;
+  body: string;
+  author: { login: string };
+  state: string;
+  labels: Array<{ name: string; color: string }>;
+  reviewers: Array<{ login: string }>;
+  baseRefName: string;
+  headRefName: string;
+  url: string;
+  additions: number;
+  deletions: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** A single file changed in the PR, parsed from the unified diff */
+export interface PrFile {
+  path: string;
+  status: 'added' | 'modified' | 'deleted' | 'renamed';
+  additions: number;
+  deletions: number;
+  /** Raw unified diff patch for this file */
+  patch: string;
+}
+
+/** A CI check from `gh pr checks --json ...` */
+export interface PrCheck {
+  name: string;
+  /** e.g. SUCCESS, FAILURE, PENDING, STARTUP_FAILURE */
+  state: string;
+  description: string;
+  detailsUrl: string;
+}
+
+/** A comment on the PR (top-level or inline) */
+export interface PrComment {
+  author: { login: string };
+  body: string;
+  createdAt: string;
+  /** File path for inline review comments */
+  path?: string;
+  /** Line number for inline review comments */
+  line?: number;
+}
+
+/** A review with its inline comments */
+export interface PrReview {
+  author: { login: string };
+  /** APPROVED, CHANGES_REQUESTED, COMMENTED, DISMISSED, PENDING */
+  state: string;
+  body: string;
+  createdAt: string;
+  comments: PrComment[];
+}
+
+/** All data collected for a PR */
+export interface PrData {
+  overview: PrOverview;
+  files: PrFile[];
+  checks: PrCheck[];
+  comments: PrComment[];
+  reviews: PrReview[];
+}

package/extensions/pr-canvas/index.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { registerPrCanvasCommands } from './commands';
+
+export default function prCanvasExtension(pi: ExtensionAPI) {
+  registerPrCanvasCommands(pi);
+}