path: root/src/main/claude/index.ts

import { query, type SDKMessage, type Query } from "@anthropic-ai/claude-agent-sdk";
import type { Session } from "../db/sessions";
import { getPhaseConfig, getNextPhase, getArtifactFilename } from "./phases";
import type { Phase, UserPermissionMode } from "./phases";
import { getProject } from "../db/projects";
import { updateSession } from "../db/sessions";
import { getSetting } from "../db/settings";
import { autoCommitTurn } from "../git";
import fs from "node:fs";
import path from "node:path";

// Track active queries by session ID
const activeQueries = new Map<string, Query>();

// Snapshot of plan.md content per session, updated after each implement turn.
// Used to detect newly-completed tasks for commit messages.
const planSnapshots = new Map<string, string>();

function ensureDir(dirPath: string): void {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
  }
}

// Artifacts live inside the project directory so the SDK's Write tool can reach them
function getSessionDir(projectPath: string, sessionId: string): string {
  return path.join(projectPath, ".claude-flow", "sessions", sessionId);
}

export interface SendMessageOptions {
  session: Session;
  message: string;
  onMessage: (msg: SDKMessage) => void;
}

export async function sendMessage({
  session,
  message,
  onMessage,
}: SendMessageOptions): Promise<void> {
  const project = getProject(session.project_id);
  if (!project) throw new Error("Project not found");

  // Ensure session artifact directory exists inside the project
  const sessionDir = getSessionDir(project.path, session.id);
  ensureDir(sessionDir);

  // Load any custom system prompt for this phase (null → use default)
  const customSystemPrompt = getSetting(`systemPrompt.${session.phase}`) ?? undefined;

  // Load global model override (empty string or null → let SDK use its default)
  const configuredModel = getSetting("model") || undefined;

  // Load MCP servers config (JSON string → object, or undefined if not set)
  const mcpServersJson = getSetting("mcpServers");
  const mcpServersConfig = mcpServersJson ? JSON.parse(mcpServersJson) : undefined;

  // Build allowedTools list from enabled MCP tools
  // Format: mcp__servername__toolname
  const mcpAllowedTools: string[] = [];
  if (mcpServersConfig) {
    for (const [serverName, config] of Object.entries(mcpServersConfig)) {
      const serverConfig = config as {
        enabledTools?: string[];
        discoveredTools?: Array<{ name: string }>;
      };
      // Use enabledTools if available, otherwise allow all discovered tools
      const enabledTools = serverConfig.enabledTools ||
        serverConfig.discoveredTools?.map((t) => t.name) ||
        [];
      for (const toolName of enabledTools) {
        mcpAllowedTools.push(`mcp__${serverName}__${toolName}`);
      }
    }
  }

  // Strip tool management fields from config before passing to SDK
  // SDK only needs: type, command, args, env, url, headers
  let mcpServers: Record<string, unknown> | undefined;
  if (mcpServersConfig && Object.keys(mcpServersConfig).length > 0) {
    mcpServers = Object.fromEntries(
      Object.entries(mcpServersConfig).map(([name, config]) => {
        const { discoveredTools, enabledTools, ...sdkConfig } = config as Record<string, unknown>;
        return [name, sdkConfig];
      })
    );
  }

  const phaseConfig = getPhaseConfig(
    session.phase as Phase,
    sessionDir,
    session.permission_mode as UserPermissionMode,
    customSystemPrompt
  );

  // Build allowedTools for this phase
  const allowedTools: string[] = [];
  if (session.phase === "implement") {
    // Allow git inspection in implement phase
    allowedTools.push("Bash(git status*)", "Bash(git log*)", "Bash(git diff*)");
  }
  if (mcpAllowedTools.length > 0) {
    // Add enabled MCP tools
    allowedTools.push(...mcpAllowedTools);
  }

  const q = query({
    prompt: message,
    options: {
      cwd: project.path,
      model: configuredModel,
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      mcpServers: mcpServers as any,
      resume: session.claude_session_id ?? undefined,
      tools: phaseConfig.tools,
      permissionMode: phaseConfig.permissionMode,
      // Required companion flag when bypassPermissions is active
      allowDangerouslySkipPermissions: phaseConfig.permissionMode === "bypassPermissions",
      systemPrompt: phaseConfig.systemPrompt,
      // Pre-approve specific tools to avoid permission prompts
      ...(allowedTools.length > 0 && { allowedTools }),
    },
  });

  activeQueries.set(session.id, q);

  try {
    for await (const msg of q) {
      // Capture session ID from init message
      if (msg.type === "system" && msg.subtype === "init") {
        if (!session.claude_session_id) {
          updateSession(session.id, { claude_session_id: msg.session_id });
        }
      }
      onMessage(msg);
    }
  } finally {
    activeQueries.delete(session.id);
  }

  // Auto-commit after a successful implement-phase turn.
  // This runs only if for-await completed without throwing (successful turn).
  // Interrupted / errored turns skip the commit.
  if (session.phase === "implement") {
    const previousPlan = planSnapshots.get(session.id) ?? "";
    const currentPlan = autoCommitTurn(
      project.path,
      session.git_branch,
      previousPlan,
      sessionDir
    );
    planSnapshots.set(session.id, currentPlan);
  }
}

export function interruptSession(sessionId: string): void {
  const q = activeQueries.get(sessionId);
  if (q) {
    q.close();
    activeQueries.delete(sessionId);
  }
}

/**
 * Trigger a review: Claude reads the document and addresses user annotations
 */
export async function triggerReview(
  session: Session,
  onMessage: (msg: SDKMessage) => void
): Promise<void> {
  const artifactPath = getArtifactPath(session);
  const message = `I've updated ${artifactPath} with annotations. Read the file, find all my inline notes (marked with // REVIEW:, // NOTE:, TODO:, or similar), address each one, and update the document accordingly. Do not implement anything yet.`;

  await sendMessage({ session, message, onMessage });
}

/**
 * Advance to the next phase
 */
export function advancePhase(session: Session): Phase | null {
  const nextPhase = getNextPhase(session.phase as Phase);
  if (nextPhase) {
    updateSession(session.id, { phase: nextPhase });
  }
  return nextPhase;
}

/**
 * Get the artifact path for a session and phase (inside the project directory)
 */
export function getArtifactPath(session: Session): string {
  const project = getProject(session.project_id);
  if (!project) throw new Error("Project not found");
  const filename = getArtifactFilename(session.phase as Phase);
  return path.join(getSessionDir(project.path, session.id), filename);
}

/**
 * Read an artifact file for a session
 */
export function readSessionArtifact(
  projectId: string,
  sessionId: string,
  filename: string
): string | null {
  const project = getProject(projectId);
  if (!project) return null;
  const filePath = path.join(getSessionDir(project.path, sessionId), filename);
  if (fs.existsSync(filePath)) {
    return fs.readFileSync(filePath, "utf-8");
  }
  return null;
}

/**
 * Write an artifact file for a session
 */
export function writeSessionArtifact(
  projectId: string,
  sessionId: string,
  filename: string,
  content: string
): void {
  const project = getProject(projectId);
  if (!project) throw new Error("Project not found");
  const dir = getSessionDir(project.path, sessionId);
  ensureDir(dir);
  fs.writeFileSync(path.join(dir, filename), content, "utf-8");
}

/**
 * Read CLAUDE.md from project root
 */
export function readClaudeMd(projectPath: string): string | null {
  const filePath = path.join(projectPath, "CLAUDE.md");
  if (fs.existsSync(filePath)) {
    return fs.readFileSync(filePath, "utf-8");
  }
  return null;
}

/**
 * Write CLAUDE.md to project root
 */
export function writeClaudeMd(projectPath: string, content: string): void {
  const filePath = path.join(projectPath, "CLAUDE.md");
  fs.writeFileSync(filePath, content, "utf-8");
}

/**
 * Clear session artifacts
 */
export function clearSessionArtifacts(projectId: string, sessionId: string): void {
  const project = getProject(projectId);
  if (!project) return;
  const dir = getSessionDir(project.path, sessionId);
  if (fs.existsSync(dir)) {
    fs.rmSync(dir, { recursive: true, force: true });
  }
}

// Re-export types
export type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
export type { Phase, UserPermissionMode } from "./phases";