circuschief 0.1.0

package/packages/server/src/api/commands.js

@@ -0,0 +1,169 @@
+import { Router } from 'express';
+import { sessions, projects } from '../database.js';
+import * as slashCommandService from '../services/slashCommandService.js';
+import { continueSession } from '../services/sessionManager.js';
+
+const router = Router();
+
+/**
+ * GET /api/commands
+ * List all available slash commands for a directory
+ *
+ * Discovers commands from:
+ * - Project .claude/commands/ folder
+ * - User ~/.claude/commands/ folder
+ * - Installed plugins
+ * - Built-in Claude Code commands
+ *
+ * Query params:
+ *   - directory: Working directory to discover commands from (required)
+ */
+router.get('/', async (req, res) => {
+  const { directory } = req.query;
+
+  if (!directory) {
+    return res.status(400).json({ error: 'directory query parameter is required' });
+  }
+
+  try {
+    const commands = await slashCommandService.getCommands(directory);
+    res.json(commands);
+  } catch (err) {
+    console.error('Error getting commands:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/**
+ * GET /api/commands/:name
+ * Get a single command's details
+ *
+ * Query params:
+ *   - directory: Working directory to discover commands from (required)
+ */
+router.get('/:name', async (req, res) => {
+  const { directory } = req.query;
+  const { name } = req.params;
+
+  if (!directory) {
+    return res.status(400).json({ error: 'directory query parameter is required' });
+  }
+
+  try {
+    const command = await slashCommandService.getCommand(directory, name);
+
+    if (!command) {
+      return res.status(404).json({ error: `Command not found: ${name}` });
+    }
+
+    res.json(command);
+  } catch (err) {
+    console.error('Error getting command:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/**
+ * POST /api/commands/:name/execute
+ * Execute a slash command in a session
+ *
+ * Body:
+ *   - sessionId: Session to execute command in (required)
+ *   - args: Object with argument values keyed by argument name (optional)
+ */
+router.post('/:name/execute', async (req, res) => {
+  const { name } = req.params;
+  const { sessionId, args = {} } = req.body;
+
+  if (!sessionId) {
+    return res.status(400).json({ error: 'sessionId is required' });
+  }
+
+  // Get the session
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  // Get the project to find the working directory
+  const project = projects.getById(session.projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  // Determine working directory (may be a worktree)
+  const workingDirectory = session.gitWorktree || project.workingDirectory;
+
+  // The session must be in a state that accepts messages (waiting, stopped, error)
+    const validStatuses = ['waiting', 'stopped', 'error'];
+    if (!validStatuses.includes(session.status)) {
+      return res.status(400).json({
+        error: `Session is not ready for commands. Current status: ${session.status}`,
+      });
+    }
+
+  try {
+    // Check if this is a skill — skills need special handling:
+    // skill body → system prompt, user args → user message
+    const skillInvocation = await slashCommandService.buildSkillInvocation(
+      workingDirectory,
+      name,
+      args
+    );
+
+    if (skillInvocation) {
+      // Skill: inject body as system prompt context, args as user message
+      const skillSystemPrompt = slashCommandService.buildSkillSystemPrompt(
+        project.systemPrompt || null,
+        skillInvocation
+      );
+      const userMessage = slashCommandService.buildSkillUserMessage(skillInvocation);
+
+      continueSession(
+        sessionId,
+        userMessage,
+        workingDirectory,
+        { systemPrompt: skillSystemPrompt } // No file attachments for slash commands
+      ).catch(err => {
+        console.error('Error executing skill:', err);
+      });
+
+      res.json({
+        success: true,
+        command: name,
+        message: userMessage,
+      });
+      return;
+    }
+
+    // Non-skill command: build command string and send as user message
+    const commandString = await slashCommandService.buildCommandString(
+      workingDirectory,
+      name,
+      args
+    );
+
+    // Use continueSession to send the command
+    // This handles the full message flow including broadcasting to WebSocket
+    continueSession(
+      sessionId,
+      commandString,
+      workingDirectory,
+      { systemPrompt: project.systemPrompt || null } // No file attachments for slash commands
+    ).catch(err => {
+      // Log but don't throw - continueSession runs asynchronously
+      console.error('Error executing command:', err);
+    });
+
+    res.json({
+      success: true,
+      command: name,
+      message: commandString,
+    });
+  } catch (err) {
+    console.error('Error executing command:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/packages/server/src/api/filesystem.js

@@ -0,0 +1,62 @@
+import { Router } from 'express';
+import { readdir } from 'fs/promises';
+import { homedir } from 'os';
+import { resolve, dirname, normalize } from 'path';
+
+const router = Router();
+
+/**
+ * GET /api/filesystem/browse - Browse directory contents
+ * Query params:
+ *   - path: Directory path to browse (defaults to home directory)
+ * Returns only directories, sorted alphabetically
+ */
+router.get('/browse', async (req, res) => {
+  try {
+    // Use provided path or default to home directory
+    const requestedPath = req.query.path ? String(req.query.path) : homedir();
+    const normalizedPath = normalize(resolve(requestedPath));
+
+    // Get parent directory (null if at root)
+    const parent = normalizedPath === '/' ? null : dirname(normalizedPath);
+
+    let entries = [];
+    let error = null;
+
+    try {
+      const dirents = await readdir(normalizedPath, { withFileTypes: true });
+
+      // Filter to only directories and sort alphabetically
+      entries = dirents
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => ({
+          name: dirent.name,
+          type: 'directory',
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    } catch (err) {
+      // Handle permission errors or non-existent directories gracefully
+      if (err.code === 'EACCES') {
+        error = 'Permission denied';
+      } else if (err.code === 'ENOENT') {
+        error = 'Directory not found';
+      } else if (err.code === 'ENOTDIR') {
+        error = 'Not a directory';
+      } else {
+        error = 'Unable to read directory';
+      }
+    }
+
+    res.json({
+      path: normalizedPath,
+      parent,
+      entries,
+      error,
+    });
+  } catch (err) {
+    console.error('Filesystem browse error:', err);
+    res.status(500).json({ error: 'Failed to browse directory' });
+  }
+});
+
+export default router;

package/packages/server/src/api/git.js

@@ -0,0 +1,85 @@
+import { Router } from 'express';
+import { projects } from '../database.js';
+import * as gitService from '../services/gitService.js';
+
+const router = Router();
+
+// GET /api/projects/:id/git/status - Check if git repo, get branches
+router.get('/projects/:id/status', async (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  try {
+    const isRepo = await gitService.isGitRepo(project.workingDirectory);
+    if (!isRepo) {
+      return res.json({ isGitRepo: false });
+    }
+
+    const [branches, currentBranch] = await Promise.all([
+      gitService.getBranches(project.workingDirectory),
+      gitService.getCurrentBranch(project.workingDirectory),
+    ]);
+
+    res.json({
+      isGitRepo: true,
+      currentBranch,
+      branches,
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// GET /api/projects/:id/git/worktrees - List worktrees
+router.get('/projects/:id/worktrees', async (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  try {
+    const worktrees = await gitService.getWorktrees(project.workingDirectory);
+    res.json(worktrees);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/projects/:id/git/worktrees - Create worktree
+router.post('/projects/:id/worktrees', async (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  const { branch, path } = req.body;
+  if (!branch || !path) {
+    return res.status(400).json({ error: 'Branch and path are required' });
+  }
+
+  try {
+    const worktree = await gitService.createWorktree(project.workingDirectory, branch, path);
+    res.status(201).json(worktree);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// DELETE /api/projects/:id/git/worktrees/:path - Remove worktree
+router.delete('/projects/:id/worktrees/:path(*)', async (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  try {
+    await gitService.removeWorktree(project.workingDirectory, req.params.path);
+    res.status(204).send();
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;

package/packages/server/src/api/index.js

@@ -0,0 +1,44 @@
+import { Router } from 'express';
+import projectsRouter from './projects.js';
+import sessionsRouter from './sessions.js';
+import templatesRouter from './templates.js';
+import canvasRouter from './canvas.js';
+import gitRouter from './git.js';
+import filesystemRouter from './filesystem.js';
+import quickResponsesRouter from './quickResponses.js';
+import settingsRouter from './settings.js';
+import providersRouter from './providers.js';
+import commandsRouter from './commands.js';
+import metricsRouter from './metrics.js';
+import kanbanRouter from './kanban.js';
+
+const router = Router();
+
+// Lightweight identity endpoint — lets tools (e.g. pw.sh) verify which
+// worktree / working directory this server instance belongs to.
+router.get('/server-info', (_req, res) => {
+  res.json({ cwd: process.cwd() });
+});
+
+router.use('/projects', projectsRouter);
+router.use('/sessions', sessionsRouter);
+router.use('/templates', templatesRouter);
+router.use('/git', gitRouter);
+router.use('/filesystem', filesystemRouter);
+router.use('/settings', settingsRouter);
+router.use('/providers', providersRouter);
+router.use('/commands', commandsRouter)
+
+// Canvas routes are nested under sessions
+router.use('/sessions', canvasRouter);
+
+// Kanban routes are nested under projects
+router.use('/projects/:projectId/kanban', kanbanRouter);
+
+// Metrics routes (agent call stats)
+router.use('/', metricsRouter);
+
+// Quick responses routes (nested under both projects and standalone)
+router.use('/', quickResponsesRouter);
+
+export default router;

package/packages/server/src/api/kanban.js

@@ -0,0 +1,342 @@
+import { Router } from 'express';
+import { kanbanBoards, kanbanLanes, kanbanCards, projects } from '../database.js';
+import { broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import {
+  CreateKanbanLaneRequest,
+  UpdateKanbanLaneRequest,
+  ReorderKanbanLanesRequest,
+  CreateKanbanCardRequest,
+  MoveKanbanCardRequest,
+  ReorderKanbanCardsRequest,
+} from '../../../shared/src/contracts/kanban.js';
+import { moveCard as moveCardService } from '../services/kanbanService.js';
+
+const router = Router({ mergeParams: true });
+
+/**
+ * Helper to build full board response with lanes and cards
+ */
+function buildFullBoardResponse(board) {
+  if (!board) return null;
+
+  const lanes = kanbanLanes.getByBoardId(board.id);
+  const allCards = kanbanCards.getByBoardId(board.id);
+
+  // Group cards by lane
+  const cardsByLane = {};
+  for (const lane of lanes) {
+    cardsByLane[lane.id] = [];
+  }
+  for (const card of allCards) {
+    if (cardsByLane[card.laneId]) {
+      cardsByLane[card.laneId].push(card);
+    }
+  }
+
+  return {
+    id: board.id,
+    projectId: board.projectId,
+    lanes: lanes.map(lane => ({
+      ...lane,
+      cards: cardsByLane[lane.id] || [],
+    })),
+    createdAt: board.createdAt,
+    updatedAt: board.updatedAt,
+  };
+}
+
+// ============== Board Endpoints ==============
+
+/**
+ * GET /api/projects/:projectId/kanban
+ * Get board with all lanes and cards. Auto-creates if kanban_enabled.
+ */
+router.get('/', (req, res) => {
+  const { projectId } = req.params;
+
+  const project = projects.getById(projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  // If kanban is disabled, return null
+  if (!project.kanbanEnabled) {
+    return res.json(null);
+  }
+
+  // Get or create board
+  const board = kanbanBoards.getOrCreateForProject(projectId);
+  const fullBoard = buildFullBoardResponse(board);
+
+  res.json(fullBoard);
+});
+
+/**
+ * DELETE /api/projects/:projectId/kanban
+ * Delete board (resets all kanban data)
+ */
+router.delete('/', (req, res) => {
+  const { projectId } = req.params;
+
+  const board = kanbanBoards.getByProjectId(projectId);
+  if (!board) {
+    return res.status(404).json({ error: 'Board not found' });
+  }
+
+  kanbanBoards.delete(board.id);
+
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: null,
+  });
+
+  res.status(204).send();
+});
+
+// ============== Lane Endpoints ==============
+
+/**
+ * POST /api/projects/:projectId/kanban/lanes
+ * Create a new lane
+ */
+router.post('/lanes', (req, res) => {
+  const { projectId } = req.params;
+
+  const result = CreateKanbanLaneRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const board = kanbanBoards.getByProjectId(projectId);
+  if (!board) {
+    return res.status(404).json({ error: 'Board not found' });
+  }
+
+  const lane = kanbanLanes.create(board.id, result.data);
+
+  // Broadcast updated board
+  const fullBoard = buildFullBoardResponse(board);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: fullBoard,
+  });
+
+  res.status(201).json(lane);
+});
+
+/**
+ * PATCH /api/projects/:projectId/kanban/lanes/:laneId
+ * Update a lane
+ */
+router.patch('/lanes/:laneId', (req, res) => {
+  const { projectId, laneId } = req.params;
+
+  const result = UpdateKanbanLaneRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const lane = kanbanLanes.getById(laneId);
+  if (!lane) {
+    return res.status(404).json({ error: 'Lane not found' });
+  }
+
+  const updated = kanbanLanes.update(laneId, result.data);
+
+  // Broadcast updated board
+  const board = kanbanBoards.getByProjectId(projectId);
+  const fullBoard = buildFullBoardResponse(board);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: fullBoard,
+  });
+
+  res.json(updated);
+});
+
+/**
+ * DELETE /api/projects/:projectId/kanban/lanes/:laneId
+ * Delete a lane
+ */
+router.delete('/lanes/:laneId', (req, res) => {
+  const { projectId, laneId } = req.params;
+
+  const lane = kanbanLanes.getById(laneId);
+  if (!lane) {
+    return res.status(404).json({ error: 'Lane not found' });
+  }
+
+  kanbanLanes.delete(laneId);
+
+  // Broadcast updated board
+  const board = kanbanBoards.getByProjectId(projectId);
+  const fullBoard = buildFullBoardResponse(board);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: fullBoard,
+  });
+
+  res.status(204).send();
+});
+
+/**
+ * PUT /api/projects/:projectId/kanban/lanes/reorder
+ * Reorder all lanes
+ */
+router.put('/lanes/reorder', (req, res) => {
+  const { projectId } = req.params;
+
+  const result = ReorderKanbanLanesRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const board = kanbanBoards.getByProjectId(projectId);
+  if (!board) {
+    return res.status(404).json({ error: 'Board not found' });
+  }
+
+  kanbanLanes.reorder(board.id, result.data);
+
+  // Broadcast updated board
+  const fullBoard = buildFullBoardResponse(board);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: fullBoard,
+  });
+
+  res.json(fullBoard);
+});
+
+// ============== Card Endpoints ==============
+
+/**
+ * POST /api/projects/:projectId/kanban/cards
+ * Add a session to the board (create card in a lane)
+ */
+router.post('/cards', (req, res) => {
+  const { projectId } = req.params;
+
+  const result = CreateKanbanCardRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const { sessionId, laneId } = result.data;
+
+  // Check if session already has a card
+  const existingCard = kanbanCards.getBySessionId(sessionId);
+  if (existingCard) {
+    return res.status(409).json({ error: 'Session already has a card on the board' });
+  }
+
+  // Verify lane exists
+  const lane = kanbanLanes.getById(laneId);
+  if (!lane) {
+    return res.status(404).json({ error: 'Lane not found' });
+  }
+
+  const card = kanbanCards.create(laneId, sessionId);
+
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_CARD_ADDED, {
+    projectId,
+    card,
+    laneId,
+  });
+
+  res.status(201).json(card);
+});
+
+/**
+ * PATCH /api/projects/:projectId/kanban/cards/:cardId/move
+ * Move card to a different lane
+ */
+router.patch('/cards/:cardId/move', async (req, res) => {
+  const { cardId } = req.params;
+
+  const result = MoveKanbanCardRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const card = kanbanCards.getByIdWithLane(cardId);
+  if (!card) {
+    return res.status(404).json({ error: 'Card not found' });
+  }
+
+  const { targetLaneId, sortOrder, runOnEnterTemplate } = result.data;
+
+  // Verify target lane exists
+  const targetLane = kanbanLanes.getById(targetLaneId);
+  if (!targetLane) {
+    return res.status(404).json({ error: 'Target lane not found' });
+  }
+
+  try {
+    const movedCard = await moveCardService(cardId, targetLaneId, {
+      sortOrder,
+      runOnEnterTemplate,
+    });
+    res.json(movedCard);
+  } catch (error) {
+    console.error('Failed to move kanban card:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * DELETE /api/projects/:projectId/kanban/cards/:cardId
+ * Remove card from board
+ */
+router.delete('/cards/:cardId', (req, res) => {
+  const { projectId, cardId } = req.params;
+
+  const card = kanbanCards.getByIdWithLane(cardId);
+  if (!card) {
+    return res.status(404).json({ error: 'Card not found' });
+  }
+
+  const laneId = card.laneId;
+  kanbanCards.delete(cardId);
+
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_CARD_REMOVED, {
+    projectId,
+    cardId,
+    laneId,
+  });
+
+  res.status(204).send();
+});
+
+/**
+ * PUT /api/projects/:projectId/kanban/lanes/:laneId/cards/reorder
+ * Reorder cards within a lane
+ */
+router.put('/lanes/:laneId/cards/reorder', (req, res) => {
+  const { projectId, laneId } = req.params;
+
+  const result = ReorderKanbanCardsRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const lane = kanbanLanes.getById(laneId);
+  if (!lane) {
+    return res.status(404).json({ error: 'Lane not found' });
+  }
+
+  kanbanCards.reorder(laneId, result.data);
+
+  // Broadcast updated board
+  const board = kanbanBoards.getByProjectId(projectId);
+  const fullBoard = buildFullBoardResponse(board);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.KANBAN_BOARD_UPDATED, {
+    projectId,
+    board: fullBoard,
+  });
+
+  res.json({ success: true });
+});
+
+export default router;