codesesh 0.1.0 → 0.1.3

package/src/api/__tests__/handlers.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { handleGetAgents, handleGetSessions, handleGetSessionData } from "../handlers.js";
-import type { ScanResult, SessionHead, SessionData } from "@codesesh/core";
-import { BaseAgent } from "@codesesh/core";
-
-// --- Helpers ---
-
-function makeSession(id: string, overrides?: Partial<SessionHead>): SessionHead {
-  return {
-    id,
-    slug: `agent/${id}`,
-    title: `Session ${id}`,
-    time_created: 1000,
-    time_updated: 1000,
-    directory: "/home/user/project",
-    ...overrides,
-  };
-}
-
-function makeMockContext(
-  overrides: {
-    query?: Record<string, string>;
-    param?: Record<string, string>;
-  } = {},
-) {
-  const jsonFn = vi.fn().mockReturnValue({ status: 200 });
-  return {
-    req: {
-      query: (key: string) => overrides.query?.[key] ?? "",
-      param: (key: string) => overrides.param?.[key] ?? "",
-    },
-    json: jsonFn,
-  } as any;
-}
-
-class MockAgent extends BaseAgent {
-  readonly name = "claudecode";
-  readonly displayName = "Claude Code";
-
-  isAvailable() {
-    return true;
-  }
-
-  scan(): SessionHead[] {
-    return [];
-  }
-
-  getSessionData(_sessionId: string): SessionData {
-    return {
-      id: "s1",
-      slug: "claudecode/s1",
-      title: "Test Session",
-      time_created: 1000,
-      time_updated: 1000,
-      messages: [],
-      stats: {
-        message_count: 0,
-        total_input_tokens: 0,
-        total_output_tokens: 0,
-        total_cost: 0,
-      },
-    };
-  }
-}
-
-function makeScanResult(overrides?: Partial<ScanResult>): ScanResult {
-  const agent = new MockAgent();
-  return {
-    sessions: [makeSession("s1"), makeSession("s2")],
-    byAgent: { claudecode: [makeSession("s1"), makeSession("s2")] },
-    agents: [agent],
-    ...overrides,
-  };
-}
-
-// --- Tests ---
-
-describe("handleGetAgents", () => {
-  it("returns agent info list", () => {
-    const c = makeMockContext();
-    const result = makeScanResult();
-    handleGetAgents(c, result);
-    expect(c.json).toHaveBeenCalled();
-    const response = c.json.mock.calls[0]![0];
-    expect(Array.isArray(response)).toBe(true);
-  });
-});
-
-describe("handleGetSessions", () => {
-  it("returns all sessions without filters", () => {
-    const c = makeMockContext();
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    expect(response.sessions).toHaveLength(2);
-  });
-
-  it("filters by agent", () => {
-    const c = makeMockContext({ query: { agent: "claudecode" } });
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    expect(response.sessions).toHaveLength(2);
-  });
-
-  it("falls back to all sessions when agent not found in byAgent", () => {
-    const c = makeMockContext({ query: { agent: "nonexistent" } });
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    // Falls back to scanResult.sessions
-    expect(response.sessions).toHaveLength(2);
-  });
-
-  it("filters by q (title search)", () => {
-    const c = makeMockContext({ query: { q: "s1" } });
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    expect(response.sessions).toHaveLength(1);
-    expect(response.sessions[0].id).toBe("s1");
-  });
-
-  it("filters by cwd (substring match)", () => {
-    const c = makeMockContext({ query: { cwd: "project" } });
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    expect(response.sessions).toHaveLength(2);
-  });
-
-  it("filters by from date", () => {
-    const c = makeMockContext({ query: { from: "2024-01-01" } });
-    const result = makeScanResult({
-      sessions: [
-        makeSession("old", { time_created: new Date("2023-01-01").getTime() }),
-        makeSession("new", { time_created: new Date("2025-01-01").getTime() }),
-      ],
-      byAgent: {},
-    });
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    expect(response.sessions).toHaveLength(1);
-    expect(response.sessions[0].id).toBe("new");
-  });
-
-  it("ignores invalid from date", () => {
-    const c = makeMockContext({ query: { from: "not-a-date" } });
-    const result = makeScanResult();
-    handleGetSessions(c, result);
-    const response = c.json.mock.calls[0]![0];
-    // Invalid date → filter not applied
-    expect(response.sessions).toHaveLength(2);
-  });
-});
-
-describe("handleGetSessionData", () => {
-  it("returns session data for valid agent and id", async () => {
-    const c = makeMockContext({ param: { agent: "claudecode", id: "s1" } });
-    const result = makeScanResult();
-    await handleGetSessionData(c, result);
-    expect(c.json).toHaveBeenCalled();
-    const response = c.json.mock.calls[0]![0];
-    expect(response.title).toBe("Test Session");
-  });
-
-  it("returns 400 when session ID is missing", async () => {
-    const c = makeMockContext({ param: { agent: "claudecode", id: "" } });
-    const result = makeScanResult();
-    await handleGetSessionData(c, result);
-    expect(c.json).toHaveBeenCalledWith({ error: "Missing session ID" }, 400);
-  });
-
-  it("returns 404 for unknown agent", async () => {
-    const c = makeMockContext({ param: { agent: "unknown", id: "s1" } });
-    const result = makeScanResult();
-    await handleGetSessionData(c, result);
-    expect(c.json).toHaveBeenCalledWith({ error: "Unknown agent: unknown" }, 404);
-  });
-
-  it("returns 500 when agent throws", async () => {
-    const agent = new MockAgent();
-    agent.getSessionData = () => {
-      throw new Error("DB not found");
-    };
-    const c = makeMockContext({ param: { agent: "claudecode", id: "s1" } });
-    const result = makeScanResult({ agents: [agent] });
-    await handleGetSessionData(c, result);
-    expect(c.json).toHaveBeenCalledWith({ error: "DB not found" }, 500);
-  });
-});

package/src/api/__tests__/routes.test.ts

@@ -1,16 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createApiRoutes } from "../routes.js";
-import type { ScanResult } from "@codesesh/core";
-
-describe("createApiRoutes", () => {
-  it("returns a Hono instance with route handlers", () => {
-    const scanResult = {
-      sessions: [],
-      byAgent: {},
-      agents: [],
-    } as unknown as ScanResult;
-    const app = createApiRoutes(scanResult);
-    expect(app).toBeDefined();
-    expect(app.fetch).toBeDefined();
-  });
-});

package/src/api/handlers.ts

@@ -1,76 +0,0 @@
-import type { Context } from "hono";
-import type { ScanResult, SessionData, SessionHead } from "@codesesh/core";
-import { getAgentInfoMap } from "@codesesh/core";
-
-export function handleGetAgents(c: Context, scanResult: ScanResult) {
-  const counts: Record<string, number> = {};
-  for (const agent of scanResult.agents) {
-    counts[agent.name] = scanResult.byAgent[agent.name]?.length ?? 0;
-  }
-  const info = getAgentInfoMap(counts);
-  return c.json(info);
-}
-
-export function handleGetSessions(c: Context, scanResult: ScanResult) {
-  const agent = c.req.query("agent");
-  const q = c.req.query("q")?.toLowerCase();
-  const cwd = c.req.query("cwd")?.toLowerCase();
-  const from = c.req.query("from");
-  const to = c.req.query("to");
-
-  let sessions: SessionHead[] = [];
-
-  // If agent filter is specified, use byAgent directly
-  if (agent && scanResult.byAgent[agent]) {
-    sessions = [...scanResult.byAgent[agent]!];
-  } else {
-    sessions = [...scanResult.sessions];
-  }
-
-  if (cwd) {
-    sessions = sessions.filter((s) => s.directory.toLowerCase().includes(cwd));
-  }
-
-  if (from) {
-    const fromTs = new Date(from).getTime();
-    if (!Number.isNaN(fromTs)) {
-      sessions = sessions.filter((s) => s.time_created >= fromTs);
-    }
-  }
-
-  if (to) {
-    const toTs = new Date(to).getTime();
-    if (!Number.isNaN(toTs)) {
-      sessions = sessions.filter((s) => s.time_created <= toTs);
-    }
-  }
-
-  if (q) {
-    sessions = sessions.filter((s) => s.title.toLowerCase().includes(q));
-  }
-
-  return c.json({ sessions });
-}
-
-export async function handleGetSessionData(c: Context, scanResult: ScanResult) {
-  const agentName = c.req.param("agent");
-  const sessionId = c.req.param("id");
-
-  if (!sessionId) {
-    return c.json({ error: "Missing session ID" }, 400);
-  }
-
-  const agent = scanResult.agents.find((a) => a.name === agentName);
-
-  if (!agent) {
-    return c.json({ error: `Unknown agent: ${agentName}` }, 404);
-  }
-
-  try {
-    const data: SessionData = agent.getSessionData(sessionId);
-    return c.json(data);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Failed to load session";
-    return c.json({ error: message }, 500);
-  }
-}

package/src/api/routes.ts

@@ -1,13 +0,0 @@
-import { Hono } from "hono";
-import type { ScanResult } from "@codesesh/core";
-import { handleGetAgents, handleGetSessions, handleGetSessionData } from "./handlers.js";
-
-export function createApiRoutes(scanResult: ScanResult): Hono {
-  const api = new Hono();
-
-  api.get("/agents", (c) => handleGetAgents(c, scanResult));
-  api.get("/sessions", (c) => handleGetSessions(c, scanResult));
-  api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanResult));
-
-  return api;
-}

package/src/commands/serve.ts

@@ -1,78 +0,0 @@
-import { defineCommand } from "citty";
-import { createServer } from "../server.js";
-import { printScanResults } from "../output.js";
-import { scanSessions, createRegisteredAgents } from "@codesesh/core";
-
-export const serveCommand = defineCommand({
-  meta: {
-    name: "serve",
-    description: "Scan sessions and start web server",
-  },
-  args: {
-    port: {
-      type: "string",
-      alias: "p",
-      default: "4321",
-    },
-    agent: {
-      type: "string",
-      alias: "a",
-    },
-    cwd: {
-      type: "string",
-    },
-    from: {
-      type: "string",
-    },
-    to: {
-      type: "string",
-    },
-    json: {
-      type: "boolean",
-      alias: "j",
-      default: false,
-    },
-    "no-open": {
-      type: "boolean",
-      default: false,
-    },
-  },
-  async run({ args }) {
-    const port = parseInt(args.port as string, 10) || 4321;
-    const noOpen = args["no-open"] as boolean;
-    const jsonOnly = args.json as boolean;
-
-    // Scan sessions
-    const result = scanSessions();
-    const agents = createRegisteredAgents();
-
-    if (jsonOnly) {
-      const { getAgentInfoMap } = await import("@codesesh/core");
-      const info = getAgentInfoMap(
-        Object.fromEntries(Object.entries(result.byAgent).map(([k, v]) => [k, v.length])),
-      );
-      const output = {
-        agents: info.map(({ name, displayName, count }) => ({
-          name,
-          displayName,
-          count,
-          available: count > 0,
-        })),
-        sessions: result.sessions,
-      };
-      console.log(JSON.stringify(output, null, 2));
-      return;
-    }
-
-    // Print console output
-    printScanResults(agents, result);
-
-    // Start server
-    const { url } = await createServer(port, result);
-
-    if (!noOpen) {
-      const open = (await import("open")).default;
-      await open(url);
-    }
-  },
-});

package/src/index.ts

@@ -1,203 +0,0 @@
-import { defineCommand, runMain } from "citty";
-import { createServer } from "./server.js";
-import { printScanResults } from "./output.js";
-import {
-  scanSessionsAsync,
-  createRegisteredAgents,
-  getAgentInfoMap,
-  type ScanOptions,
-  perf,
-} from "@codesesh/core";
-
-const VERSION = "0.1.0";
-
-function parseDateToTimestamp(dateStr: string): number {
-  const date = new Date(dateStr);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid date: ${dateStr}`);
-  }
-  return date.getTime();
-}
-
-function parseSessionUri(uri: string): { agent: string; sessionId: string } | null {
-  const match = uri.match(/^([a-z]+):\/\/(.+)$/i);
-  if (!match) return null;
-  return { agent: match[1]!, sessionId: match[2]! };
-}
-
-const main = defineCommand({
-  meta: {
-    name: "codesesh",
-    description: "Discover, aggregate, and visualize AI coding agent sessions",
-    version: VERSION,
-  },
-  args: {
-    port: {
-      type: "string",
-      alias: "p",
-      description: "HTTP server port",
-      default: "4321",
-    },
-    agent: {
-      type: "string",
-      alias: "a",
-      description: "Filter to specific agent(s), comma-separated",
-    },
-    days: {
-      type: "string",
-      alias: "d",
-      description: "Only include sessions from the last N days (0 = all time)",
-      default: "7",
-    },
-    cwd: {
-      type: "string",
-      description: "Filter to sessions from a specific project directory (use '.' for current dir)",
-    },
-    from: {
-      type: "string",
-      description: "Sessions created after this date, YYYY-MM-DD (overrides --days)",
-    },
-    to: {
-      type: "string",
-      description: "Sessions created before this date (YYYY-MM-DD)",
-    },
-    session: {
-      type: "string",
-      alias: "s",
-      description: "Directly open a specific session (agent://session-id)",
-    },
-    json: {
-      type: "boolean",
-      alias: "j",
-      description: "Output session index as JSON to stdout (no server)",
-      default: false,
-    },
-    noOpen: {
-      type: "boolean",
-      description: "Don't auto-open browser",
-      default: false,
-    },
-    trace: {
-      type: "boolean",
-      description: "Show performance trace logs",
-      default: false,
-    },
-    cache: {
-      type: "boolean",
-      description: "Use cached scan results if available",
-      default: true,
-    },
-    "clear-cache": {
-      type: "boolean",
-      description: "Clear scan cache before starting",
-      default: false,
-    },
-  },
-  async run({ args }) {
-    const port = parseInt(args.port as string, 10) || 4321;
-    const noOpen = args.noOpen as boolean;
-    const jsonOnly = args.json as boolean;
-    const trace = args.trace as boolean;
-    const useCache = args.cache as boolean;
-    const clearCache = args["clear-cache"] as boolean;
-
-    if (trace) {
-      perf.enable();
-    }
-
-    if (clearCache) {
-      const { clearCache: clear } = await import("@codesesh/core");
-      clear();
-      console.log("Cache cleared.");
-    }
-
-    // Parse session URI if provided
-    let targetSession: { agent: string; sessionId: string } | null = null;
-    if (args.session) {
-      targetSession = parseSessionUri(args.session as string);
-      if (!targetSession) {
-        console.error(`Invalid session format: ${args.session}. Expected: agent://session-id`);
-        process.exit(1);
-      }
-    }
-
-    // Resolve cwd filter: '.' => process.cwd()
-    let cwdFilter = args.cwd as string | undefined;
-    if (cwdFilter === ".") {
-      cwdFilter = process.cwd();
-    }
-
-    // Resolve from timestamp: --from takes priority over --days
-    let fromTimestamp: number | undefined;
-    if (args.from) {
-      fromTimestamp = parseDateToTimestamp(args.from as string);
-    } else {
-      const days = parseInt(args.days as string, 10);
-      if (!Number.isNaN(days) && days > 0) {
-        fromTimestamp = Date.now() - days * 24 * 60 * 60 * 1000;
-      }
-    }
-
-    // Build scan options
-    const scanOptions: ScanOptions = {
-      agents: targetSession
-        ? [targetSession.agent]
-        : args.agent
-          ? (args.agent as string).split(",").map((a) => a.trim())
-          : undefined,
-      cwd: cwdFilter,
-      from: fromTimestamp,
-      to: args.to ? parseDateToTimestamp(args.to as string) : undefined,
-      useCache: useCache,
-    };
-
-    // Scan sessions (parallel)
-    const result = await scanSessionsAsync(scanOptions);
-
-    if (trace) {
-      console.log(perf.getReport());
-    }
-
-    if (jsonOnly) {
-      const info = getAgentInfoMap(
-        Object.fromEntries(Object.entries(result.byAgent).map(([k, v]) => [k, v.length])),
-      );
-      const output = {
-        agents: info.map(({ name, displayName, count }) => ({
-          name,
-          displayName,
-          count,
-          available: count > 0,
-        })),
-        sessions: result.sessions,
-      };
-      console.log(JSON.stringify(output, null, 2));
-      return;
-    }
-
-    // Print console output
-    const agents = createRegisteredAgents();
-    printScanResults(agents, result);
-
-    // Start server
-    const { url } = await createServer(port, result);
-
-    console.log(`  http://localhost:${port}`);
-    console.log("");
-
-    if (!noOpen) {
-      const open = (await import("open")).default;
-      const targetUrl = targetSession
-        ? `${url}/${targetSession.agent.toLowerCase()}/${targetSession.sessionId}`
-        : url;
-      await open(targetUrl);
-    }
-  },
-});
-
-if (process.argv.slice(2).includes("-v")) {
-  console.log(VERSION);
-  process.exit(0);
-}
-
-runMain(main);

package/src/output.ts

@@ -1,47 +0,0 @@
-import { consola } from "consola";
-import type { BaseAgent } from "@codesesh/core";
-import type { ScanResult } from "@codesesh/core";
-
-export function printScanResults(agents: BaseAgent[], result: ScanResult): void {
-  consola.log("");
-  consola.box({
-    title: "CodeSesh",
-    message: `v0.1.0 • ${result.sessions.length} sessions discovered`,
-    style: {
-      padding: 1,
-      borderColor: "cyan",
-    },
-  });
-  consola.log("");
-
-  const rows: string[] = [];
-  let availableCount = 0;
-
-  for (const agent of agents) {
-    const sessions = result.byAgent[agent.name];
-    const count = sessions?.length ?? 0;
-    if (count > 0) {
-      availableCount++;
-      rows.push(`  ${green("✔")} ${pad(agent.displayName)} ${dim(`${count} sessions`)}`);
-    } else {
-      rows.push(`  ${dim("✖")} ${pad(agent.displayName)} ${dim("not found")}`);
-    }
-  }
-
-  consola.log(rows.join("\n"));
-  consola.log("");
-  consola.info(`Active: ${availableCount}/${agents.length} agents`);
-  consola.log("");
-}
-
-function pad(text: string, length = 16): string {
-  return text.padEnd(length);
-}
-
-function green(text: string): string {
-  return `\x1b[32m${text}\x1b[0m`;
-}
-
-function dim(text: string): string {
-  return `\x1b[2m${text}\x1b[0m`;
-}

package/src/server.ts

@@ -1,56 +0,0 @@
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { logger } from "hono/logger";
-import { existsSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { ScanResult } from "@codesesh/core";
-import { createApiRoutes } from "./api/routes.js";
-
-function findWebDistPath(): string | null {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-
-  // Priority 1: Packaged web dist (copied during build)
-  const packagedPath = resolve(__dirname, "../web");
-  if (existsSync(packagedPath)) {
-    return packagedPath;
-  }
-
-  // Priority 2: Development path (monorepo)
-  const devPath = resolve(__dirname, "../../../apps/web/dist");
-  if (existsSync(devPath)) {
-    return devPath;
-  }
-
-  return null;
-}
-
-export async function createServer(
-  port: number,
-  scanResult: ScanResult,
-): Promise<{ url: string; shutdown: () => void }> {
-  const app = new Hono();
-
-  app.use("*", logger());
-
-  // API routes
-  app.route("/api", createApiRoutes(scanResult));
-
-  // Serve static files from web dist (if available)
-  const webDistPath = findWebDistPath();
-
-  if (webDistPath) {
-    app.use("/*", serveStatic({ root: webDistPath }));
-    app.get("/*", serveStatic({ root: webDistPath, path: "index.html" }));
-  }
-
-  const server = serve({ fetch: app.fetch, port });
-
-  const url = `http://localhost:${port}`;
-
-  return {
-    url,
-    shutdown: () => server.close(),
-  };
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "types": ["node"]
-  },
-  "include": ["src"]
-}