circuschief 0.1.0

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

@@ -0,0 +1,194 @@
+import { Router } from 'express';
+import { agentCallLogger } from '../services/agentCallLogger.js';
+import { agentCallLogs } from '../database.js';
+import { databaseManager } from '../db/DatabaseManager.js';
+
+const router = Router();
+
+/**
+ * Resolve metadata to a JSON string. Uses provided metadata or derives from session effortLevel.
+ */
+function resolveMetadataJson(providedMetadata, sessionId) {
+  let metadata = providedMetadata || {};
+  if (!providedMetadata) {
+    const session = agentCallLogs.db
+      .prepare('SELECT effort_level FROM sessions WHERE id = ?')
+      .get(sessionId);
+    if (session && session.effort_level) {
+      metadata = { effortLevel: session.effort_level };
+    }
+  }
+  return Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : null;
+}
+
+// GET /api/sessions/:sessionId/agent-stats
+// Returns aggregated stats for a session grouped by call_type
+router.get('/sessions/:sessionId/agent-stats', (req, res) => {
+  const stats = agentCallLogger.getSessionStats(req.params.sessionId);
+  res.json(stats);
+});
+
+// GET /api/sessions/:sessionId/agent-calls?limit=100&offset=0
+// Returns detailed call log entries for a session
+router.get('/sessions/:sessionId/agent-calls', (req, res) => {
+  const { limit = 100, offset = 0 } = req.query;
+  const calls = agentCallLogs.getBySessionId(req.params.sessionId, {
+    limit: parseInt(limit),
+    offset: parseInt(offset),
+  });
+  res.json(calls);
+});
+
+// GET /api/agent-stats?startDate=...&endDate=...
+// Returns global stats grouped by agent_type and call_type
+router.get('/agent-stats', (req, res) => {
+  const now = Date.now();
+  const start = req.query.startDate
+    ? parseInt(req.query.startDate)
+    : now - 7 * 24 * 60 * 60 * 1000;
+  const end = req.query.endDate ? parseInt(req.query.endDate) : now;
+  const stats = agentCallLogger.getGlobalStats(start, end);
+  res.json(stats);
+});
+
+// GET /api/agent-calls/filter-options
+// Returns distinct values for filter dropdowns
+router.get('/agent-calls/filter-options', (req, res) => {
+  try {
+    const options = agentCallLogger.getFilterOptions();
+    res.json(options);
+  } catch (err) {
+    console.error('Failed to get filter options:', err);
+    res.status(500).json({ error: 'Failed to get filter options' });
+  }
+});
+
+// GET /api/agent-calls?limit=25&offset=0&agentType=...&callType=...&status=...&model=...&sessionId=...&startDate=...&endDate=...&sortBy=...&sortOrder=...
+// Returns paginated call logs with optional filters
+router.get('/agent-calls', (req, res) => {
+  try {
+    const limit = req.query.limit ? parseInt(req.query.limit) : 25;
+    const offset = req.query.offset ? parseInt(req.query.offset) : 0;
+    const startDate = req.query.startDate ? parseInt(req.query.startDate) : undefined;
+    const endDate = req.query.endDate ? parseInt(req.query.endDate) : undefined;
+
+    const result = agentCallLogger.getAll({
+      limit,
+      offset,
+      agentType: req.query.agentType,
+      callType: req.query.callType,
+      status: req.query.status,
+      model: req.query.model,
+      sessionId: req.query.sessionId,
+      startDate,
+      endDate,
+      sortBy: req.query.sortBy,
+      sortOrder: req.query.sortOrder,
+    });
+
+    res.json({
+      logs: result.rows,
+      pagination: {
+        total: result.total,
+        limit,
+        offset,
+        hasMore: offset + limit < result.total,
+      },
+    });
+  } catch (err) {
+    console.error('Failed to get agent call logs:', err);
+    res.status(500).json({ error: 'Failed to get agent call logs' });
+  }
+});
+
+// POST /api/agent-calls
+// Seed a fully-formed agent call log entry (for E2E testing only).
+// Accepts all fields directly, including computed ones (totalTokens, durationMs).
+router.post('/agent-calls', (req, res) => {
+  try {
+    const {
+      sessionId,
+      agentType = 'claude-code',
+      callType = 'runSession',
+      model = null,
+      status = 'completed',
+      inputTokens = 0,
+      outputTokens = 0,
+      thinkingTokens = 0,
+      cacheReadTokens = 0,
+      cacheWriteTokens = 0,
+      durationMs = null,
+      startedAt = null,
+      errorMessage = null,
+      metadata: providedMetadata,
+    } = req.body;
+
+    if (!sessionId) {
+      return res.status(400).json({ error: 'sessionId is required' });
+    }
+
+    const metadataJson = resolveMetadataJson(providedMetadata, sessionId);
+
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    const finalStartedAt = startedAt ?? now;
+    const completedAt =
+      status === 'completed' || status === 'error'
+        ? durationMs != null
+          ? finalStartedAt + durationMs
+          : now
+        : null;
+    const totalTokens =
+      inputTokens + outputTokens + thinkingTokens + cacheReadTokens + cacheWriteTokens;
+    const finalDurationMs = completedAt != null ? completedAt - finalStartedAt : null;
+
+    // Direct INSERT — bypasses create()/complete() flow to allow full control over all fields,
+    // including computed ones like totalTokens, durationMs, and startedAt.
+    const db = agentCallLogs.db;
+    db.prepare(`
+      INSERT INTO agent_call_logs (
+        id, session_id, agent_type, model, call_type, prompt_length,
+        input_tokens, output_tokens, thinking_tokens, cache_read_tokens, cache_write_tokens,
+        total_tokens, started_at, completed_at, duration_ms, status, error_message, metadata, created_at
+      ) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      sessionId,
+      agentType,
+      model,
+      callType,
+      inputTokens,
+      outputTokens,
+      thinkingTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens,
+      finalStartedAt,
+      completedAt,
+      finalDurationMs,
+      status,
+      errorMessage,
+      metadataJson,
+      now
+    );
+
+    res.status(201).json(agentCallLogs.getById(id));
+  } catch (err) {
+    console.error('Failed to seed agent call log:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// DELETE /api/agent-calls
+// Deletes all agent call logs from the database and clears the in-memory active calls map
+router.delete('/agent-calls', (req, res) => {
+  try {
+    const deleted = agentCallLogger.deleteAllLogs();
+    res.json({ success: true, deleted });
+  } catch (err) {
+    console.error('Failed to delete agent call logs:', err);
+    res.status(500).json({ error: 'Failed to delete agent call logs' });
+  }
+});
+
+export default router;

package/packages/server/src/api/projects-helpers.js

@@ -0,0 +1,43 @@
+import { isGitRepo } from '../services/gitService.js';
+
+/**
+ * Validate that git projects have required gitMode and gitBranch settings.
+ * @param {Object} config - The session configuration
+ * @param {Object} project - The project object
+ * @returns {Promise<string|null>} Error message if validation fails, null otherwise.
+ */
+export async function validateGitSettings(config, project) {
+  if (!config.gitMode || !config.gitBranch) {
+    const isGit = await isGitRepo(project.workingDirectory);
+    if (isGit) {
+      return 'Git projects require both gitMode and gitBranch. Set project defaults or provide them per-session.';
+    }
+  }
+  return null;
+}
+
+/**
+ * Build a merged index of latest command runs per session.
+ * Running commands from memory take precedence over completed DB runs.
+ * @param {Array} dbRuns - Completed runs from the database
+ * @param {Array} runningRuns - Currently running commands from memory
+ * @returns {Object} sessionId -> { buttonId -> run }
+ */
+export function buildRunsBySession(dbRuns, runningRuns) {
+  const runsBySession = {};
+  for (const run of dbRuns) {
+    if (!runsBySession[run.sessionId]) runsBySession[run.sessionId] = {};
+    runsBySession[run.sessionId][run.buttonId] = {
+      buttonId: run.buttonId, status: run.status, exitCode: run.exitCode,
+      runId: run.id, startedAt: run.startedAt, completedAt: run.completedAt,
+    };
+  }
+  for (const run of runningRuns) {
+    if (!runsBySession[run.sessionId]) runsBySession[run.sessionId] = {};
+    runsBySession[run.sessionId][run.buttonId] = {
+      buttonId: run.buttonId, status: 'running', exitCode: null,
+      runId: run.runId, startedAt: run.startedAt,
+    };
+  }
+  return runsBySession;
+}

package/packages/server/src/api/projects-session-helpers.js

@@ -0,0 +1,295 @@
+import { sessions, sessionTemplates, attachments } from '../database.js';
+import * as slashCommandService from '../services/slashCommandService.js';
+import { setupGitForSession } from '../services/gitSessionSetup.js';
+import { executeHookAsync } from '../services/hookService.js';
+import { broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+
+/**
+ * Generate an initial session name from the prompt
+ * This will be replaced by a better name when the summary is generated
+ * @param {string} prompt - The user's initial prompt
+ * @returns {string} A truncated version of the prompt (max 50 chars)
+ */
+export function generateInitialName(prompt) {
+  const cleaned = prompt.trim().replace(/\s+/g, ' ');
+  if (cleaned.length <= 50) return cleaned;
+  const truncated = cleaned.substring(0, 50);
+  const lastSpace = truncated.lastIndexOf(' ');
+  return `${lastSpace > 20 ? truncated.substring(0, lastSpace) : truncated  }...`;
+}
+
+/**
+ * Parse a boolean-like value from a request body field.
+ * Handles true, false, 'true', 'false', and undefined/null.
+ * @param {*} value - The raw value from request body
+ * @returns {{ explicit: boolean, provided: boolean }} parsed result
+ */
+export function parseBooleanField(value) {
+  if (value === true || value === 'true') return { explicit: true, provided: true };
+  if (value === false || value === 'false') return { explicit: false, provided: true };
+  return { explicit: undefined, provided: false };
+}
+
+/**
+ * Resolve a value with cascading defaults: explicit > project default > system default
+ * @param {*} explicit - Explicitly provided value
+ * @param {*} projectDefault - Project-level default
+ * @param {*} systemDefault - System-level default
+ * @returns {*} The resolved value
+ */
+export function resolveDefault(explicit, projectDefault, systemDefault) {
+  if (explicit) return explicit;
+  if (projectDefault) return projectDefault;
+  return systemDefault;
+}
+
+/**
+ * Resolve thinkingEnabled with special boolean handling.
+ * @param {object} body - Request body
+ * @param {object|null} projectDefs - Project defaults
+ * @param {object} systemDefaults - System defaults
+ * @returns {boolean}
+ */
+export function resolveThinkingEnabled(body, projectDefs, systemDefaults) {
+  const thinkingParsed = parseBooleanField(body.thinkingEnabled);
+  if (thinkingParsed.provided) {
+    return thinkingParsed.explicit;
+  }
+  if (projectDefs?.thinkingEnabled !== undefined && projectDefs?.thinkingEnabled !== null) {
+    return projectDefs.thinkingEnabled;
+  }
+  return systemDefaults.thinkingEnabled;
+}
+
+/**
+ * Parse scheduling fields from request body.
+ * @param {object} body - Request body
+ * @returns {object} Scheduling configuration
+ */
+export function parseSchedulingConfig(body) {
+  return {
+    scheduledAt: body.scheduledAt ? parseInt(body.scheduledAt, 10) : undefined,
+    autoRescheduleEnabled: body.autoRescheduleEnabled === true || body.autoRescheduleEnabled === 'true',
+    rescheduleDelayMinutes: body.rescheduleDelayMinutes ? parseInt(body.rescheduleDelayMinutes, 10) : 15,
+    rescheduleOnTokenLimit: body.rescheduleOnTokenLimit !== false && body.rescheduleOnTokenLimit !== 'false',
+    rescheduleOnServiceError: body.rescheduleOnServiceError !== false && body.rescheduleOnServiceError !== 'false',
+    maxRescheduleCount: body.maxRescheduleCount ? parseInt(body.maxRescheduleCount, 10) : null,
+    maxTotalTokens: body.maxTotalTokens ? parseInt(body.maxTotalTokens, 10) : null,
+    rescheduleAtTokenCount: body.rescheduleAtTokenCount ? parseInt(body.rescheduleAtTokenCount, 10) : null,
+  };
+}
+
+/**
+ * Resolve startImmediately with special boolean handling.
+ * Default is true unless overridden by project/system defaults.
+ * @param {object} body - Request body
+ * @param {object|null} projectDefs - Project defaults
+ * @param {object} systemDefaults - System defaults
+ * @returns {boolean}
+ */
+export function resolveStartImmediately(body, projectDefs, systemDefaults) {
+  let startImmediately = body.startImmediately !== false && body.startImmediately !== 'false';
+  if (body.startImmediately === undefined || body.startImmediately === null) {
+    if (projectDefs?.startImmediately !== undefined && projectDefs?.startImmediately !== null) {
+      startImmediately = projectDefs.startImmediately;
+    } else {
+      startImmediately = systemDefaults.startImmediately;
+    }
+  }
+  return startImmediately;
+}
+
+/**
+ * Build session configuration from request body, project defaults, and system defaults.
+ * @param {object} body - The request body
+ * @param {object|null} projectDefs - Project-level defaults
+ * @param {object} systemDefaults - System-level defaults
+ * @returns {object} Session configuration
+ */
+export function prepareSessionConfig(body, projectDefs, systemDefaults) {
+  let effortLevel = resolveDefault(body.effortLevel || null, projectDefs?.effortLevel, systemDefaults.effortLevel);
+  // Normalize 'auto' to null
+  if (effortLevel === 'auto') {
+    effortLevel = null;
+  }
+
+  return {
+    prompt: body.prompt,
+    name: body.name,
+    mode: resolveDefault(body.mode, projectDefs?.mode, systemDefaults.mode),
+    model: resolveDefault(body.model, projectDefs?.model, systemDefaults.model || null),
+    effortLevel,
+    gitBranch: resolveDefault(body.gitBranch, projectDefs?.gitBranch, null),
+    gitMode: resolveDefault(body.gitMode, projectDefs?.gitMode, null),
+    templateId: body.templateId,
+    parentSessionId: body.parentSessionId || null,
+    files: [],
+    thinkingEnabled: resolveThinkingEnabled(body, projectDefs, systemDefaults),
+    startImmediately: resolveStartImmediately(body, projectDefs, systemDefaults),
+    ...parseSchedulingConfig(body),
+  };
+}
+
+/**
+ * Apply template overrides to session config.
+ * Mutates the config object in place.
+ * @param {object} configInput - Session config to modify
+ */
+export function applyTemplateOverrides(configInput) {
+  const config = configInput;
+  if (!config.templateId) return;
+
+  const template = sessionTemplates.getById(config.templateId);
+  if (!template) return;
+
+  if (template.thinkingEnabled !== null && template.thinkingEnabled !== undefined) {
+    config.thinkingEnabled = template.thinkingEnabled;
+  }
+  if (template.gitBranch) {
+    config.gitBranch = template.gitBranch;
+  }
+  if (template.gitMode) {
+    config.gitMode = template.gitMode;
+  }
+  if (template.effortLevel !== null && template.effortLevel !== undefined) {
+    config.effortLevel = template.effortLevel;
+    // Normalize 'auto' to null (same as prepareSessionConfig)
+    if (config.effortLevel === 'auto') {
+      config.effortLevel = null;
+    }
+  }
+  config.nextTemplateId = config.templateId;
+}
+
+/**
+ * Resolve the nextTemplateId from explicit body value or template-derived value.
+ * @param {object} body - Request body
+ * @param {string|null} derivedNextTemplateId - nextTemplateId derived from templateId
+ * @returns {{ nextTemplateId: string|null, error: string|null }}
+ */
+export function resolveNextTemplateId(body, derivedNextTemplateId) {
+  if (body.nextTemplateId === undefined) {
+    return { nextTemplateId: derivedNextTemplateId, error: null };
+  }
+
+  if (body.nextTemplateId === null) {
+    return { nextTemplateId: null, error: null };
+  }
+
+  const nextTemplate = sessionTemplates.getById(body.nextTemplateId);
+  if (!nextTemplate) {
+    return { nextTemplateId: null, error: 'nextTemplateId references a non-existent template' };
+  }
+  return { nextTemplateId: body.nextTemplateId, error: null };
+}
+
+/**
+ * Determine the initial session status based on config.
+ * @param {object} config - Session config
+ * @returns {string|undefined} Initial status, or undefined for default
+ */
+export function determineInitialStatus(config) {
+  if (config.scheduledAt && config.scheduledAt > Date.now()) return 'scheduled';
+  if (!config.startImmediately) return 'waiting';
+  return undefined;
+}
+
+/**
+ * Build the scheduling update object from config.
+ * @param {object} config - Session config
+ * @param {string|undefined} initialStatus - Initial session status
+ * @returns {object} Fields to update on the session for scheduling
+ */
+export function buildSchedulingUpdate(config, initialStatus) {
+  const update = {};
+  if (config.scheduledAt !== undefined) update.scheduledAt = config.scheduledAt;
+  if (config.autoRescheduleEnabled !== undefined) update.autoRescheduleEnabled = config.autoRescheduleEnabled;
+  if (config.rescheduleDelayMinutes !== undefined) update.rescheduleDelayMinutes = config.rescheduleDelayMinutes;
+  if (config.rescheduleOnTokenLimit !== undefined) update.rescheduleOnTokenLimit = config.rescheduleOnTokenLimit;
+  if (config.rescheduleOnServiceError !== undefined) update.rescheduleOnServiceError = config.rescheduleOnServiceError;
+  if (config.maxRescheduleCount !== undefined) update.maxRescheduleCount = config.maxRescheduleCount;
+  if (config.maxTotalTokens !== undefined) update.maxTotalTokens = config.maxTotalTokens;
+  if (config.rescheduleAtTokenCount !== undefined) update.rescheduleAtTokenCount = config.rescheduleAtTokenCount;
+
+  if (initialStatus === 'waiting' || initialStatus === 'scheduled') {
+    update.pendingPrompt = config.prompt;
+    update.pendingModel = config.model;
+  }
+
+  return update;
+}
+
+/**
+ * Handle git setup, session start, broadcasts, and hooks after session creation.
+ * @param {object} params
+ * @param {object} params.session - The created session record
+ * @param {object} params.config - Session config
+ * @param {object} params.project - Project record
+ * @param {string} params.projectId - Project ID
+ * @param {Array} params.files - Uploaded files
+ * @returns {Promise<{ updatedSession: object }>}
+ */
+export async function setupAndStartSession({ session, config, project, projectId, files }) {
+  let workingDirectory;
+  let gitWorktree = null;
+
+  // If this is a child session and the parent has a worktree, inherit it
+  // (mirrors templateTriggerService behavior)
+  const parentSession = config.parentSessionId ? sessions.getById(config.parentSessionId) : null;
+  if (parentSession?.gitWorktree) {
+    workingDirectory = parentSession.gitWorktree;
+    gitWorktree = parentSession.gitWorktree;
+  } else {
+    const gitSetup = await setupGitForSession({
+      projectDir: project.workingDirectory,
+      gitMode: config.gitMode || null,
+      gitBranch: config.gitBranch || null,
+      sessionId: session.id,
+    });
+    workingDirectory = gitSetup.workingDirectory;
+    gitWorktree = gitSetup.gitWorktree;
+  }
+
+  if (gitWorktree) {
+    sessions.update(session.id, { gitWorktree });
+  }
+
+  const sessionAttachments = attachments.createBatch(session.id, null, files, workingDirectory);
+
+  const isScheduled = config.scheduledAt && config.scheduledAt > Date.now();
+  if (config.startImmediately && !isScheduled) {
+    const resolved = await slashCommandService.resolvePromptSkillOrCommand(
+      workingDirectory, config.prompt, project.systemPrompt
+    );
+    const finalPrompt = resolved ? resolved.userMessage : config.prompt;
+    const finalSystemPrompt = resolved ? resolved.systemPrompt : project.systemPrompt;
+
+    const { runSession } = await import('../services/sessionManager.js');
+    runSession(session.id, finalPrompt, workingDirectory, {
+      systemPrompt: finalSystemPrompt,
+      fileAttachments: sessionAttachments,
+      model: config.model,
+    }).catch((error) => {
+      console.error('Session error:', error);
+      sessions.update(session.id, { status: 'error', error: error.message });
+    });
+  }
+
+  const updatedSession = sessions.getById(session.id);
+
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.SESSION_CREATED, {
+    projectId,
+    session: updatedSession,
+  });
+
+  if (project.onSessionCreated) {
+    executeHookAsync(project.onSessionCreated, workingDirectory, {
+      sessionId: session.id,
+      projectId: project.id,
+      sessionName: session.name,
+    });
+  }
+
+  return { updatedSession };
+}