tower-studio 0.1.1 → 0.1.3

package/src/actions/project-actions.ts

@@ -0,0 +1,222 @@
+"use server";
+
+import { rename, mkdir, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import { db } from "@/lib/db";
+import { revalidatePath } from "next/cache";
+
+/**
+ * Pre-flight safety check for project migration.
+ * Returns { safe: true } if migration is allowed,
+ * or { safe: false, reason: string } explaining why not.
+ */
+export async function checkMigrationSafety(
+  projectId: string
+): Promise<{ safe: true } | { safe: false; reason: string }> {
+  if (!projectId || typeof projectId !== "string") {
+    return { safe: false, reason: "无效的项目 ID" };
+  }
+
+  const project = await db.project.findUnique({ where: { id: projectId } });
+  if (!project || !project.localPath) {
+    return { safe: false, reason: "项目不存在或未设置本地路径" };
+  }
+
+  // Check running executions
+  const runningExecutions = await db.taskExecution.findMany({
+    where: { task: { projectId }, status: "RUNNING" },
+    select: { id: true },
+  });
+  if (runningExecutions.length > 0) {
+    return { safe: false, reason: "该项目有正在运行的任务执行，请先停止所有执行" };
+  }
+
+  // Check active PTY sessions
+  const tasks = await db.task.findMany({
+    where: { projectId },
+    select: { id: true },
+  });
+  const { getSession } = await import("@/lib/pty/session-store");
+  for (const task of tasks) {
+    if (getSession(task.id) !== undefined) {
+      return { safe: false, reason: "该项目有活跃的终端会话，请先关闭" };
+    }
+  }
+
+  // Check existing worktrees
+  const worktreesDir = path.join(project.localPath, ".worktrees");
+  if (existsSync(worktreesDir)) {
+    try {
+      const entries = await readdir(worktreesDir);
+      if (entries.length > 0) {
+        return { safe: false, reason: "该项目有活跃的 Git Worktree，请先清理" };
+      }
+    } catch {
+      // If we can't read, assume no worktrees
+    }
+  }
+
+  return { safe: true };
+}
+
+/**
+ * Atomically migrate a project directory to a new path.
+ * Uses fs.rename (same-filesystem only, EXDEV = hard error).
+ */
+export async function migrateProjectPath(
+  projectId: string,
+  targetPath: string
+): Promise<{ success: true } | { success: false; error: string }> {
+  // Validate inputs
+  if (!projectId || typeof projectId !== "string") {
+    return { success: false, error: "无效的项目 ID" };
+  }
+  if (!targetPath || typeof targetPath !== "string" || !path.isAbsolute(targetPath)) {
+    return { success: false, error: "目标路径必须是非空的绝对路径" };
+  }
+
+  // Load project
+  const project = await db.project.findUnique({ where: { id: projectId } });
+  if (!project || !project.localPath) {
+    return { success: false, error: "项目不存在或未设置本地路径" };
+  }
+
+  const sourcePath = project.localPath;
+
+  // Pre-flight: same path check
+  if (targetPath === sourcePath) {
+    return { success: false, error: "源路径和目标路径相同" };
+  }
+
+  // Pre-flight: running executions
+  const runningExecutions = await db.taskExecution.findMany({
+    where: { task: { projectId }, status: "RUNNING" },
+    select: { id: true },
+  });
+  if (runningExecutions.length > 0) {
+    return { success: false, error: "该项目有正在运行的任务执行，请先停止所有执行" };
+  }
+
+  // Pre-flight: active PTY sessions
+  const tasks = await db.task.findMany({
+    where: { projectId },
+    select: { id: true },
+  });
+  const { getSession } = await import("@/lib/pty/session-store");
+  for (const task of tasks) {
+    if (getSession(task.id) !== undefined) {
+      return { success: false, error: "该项目有活跃的终端会话，请先关闭" };
+    }
+  }
+
+  // Pre-flight: existing worktrees
+  const worktreesDir = path.join(sourcePath, ".worktrees");
+  if (existsSync(worktreesDir)) {
+    try {
+      const entries = await readdir(worktreesDir);
+      if (entries.length > 0) {
+        return { success: false, error: "该项目有活跃的 Git Worktree，请先清理" };
+      }
+    } catch {
+      // If we can't read, assume no worktrees
+    }
+  }
+
+  // Pre-flight: target path
+  if (existsSync(targetPath)) {
+    try {
+      const entries = await readdir(targetPath);
+      if (entries.length > 0) {
+        return { success: false, error: "目标路径已存在且不为空" };
+      }
+    } catch {
+      return { success: false, error: "目标路径已存在且不为空" };
+    }
+  }
+
+  // Create parent directory
+  await mkdir(path.dirname(targetPath), { recursive: true });
+
+  // Atomic rename
+  try {
+    await rename(sourcePath, targetPath);
+  } catch (err: unknown) {
+    const error = err as NodeJS.ErrnoException;
+    if (error.code === "EXDEV") {
+      return { success: false, error: "源路径和目标路径不在同一文件系统，不支持跨设备迁移" };
+    }
+    return { success: false, error: error.message || "文件系统操作失败" };
+  }
+
+  // Update database
+  await db.project.update({
+    where: { id: projectId },
+    data: { localPath: targetPath },
+  });
+
+  // Revalidate
+  revalidatePath("/workspaces");
+
+  return { success: true };
+}
+
+/**
+ * Analyze a project directory using Claude CLI one-shot and return a structured
+ * Markdown description of the project's tech stack, module structure, and entry points.
+ *
+ * @param localPath - Absolute path to the project directory (no tilde aliases)
+ * @returns Trimmed Markdown string from Claude CLI output
+ * @throws Error if path is invalid or CLI invocation fails
+ */
+const ANALYZE_PROMPT_ZH = `分析这个项目目录，生成一段简短的 Markdown 项目描述。
+
+读取 package.json、README.md 等关键文件，然后概括：
+
+**技术栈：** 一句话列出主要语言、框架、关键库
+**定位：** 一句话说明项目是什么
+**核心模块：** 2-3 个关键模块，每个一句话
+
+要求：
+- 总字数不超过 500 字
+- 用简洁的 Markdown（加粗标签 + 短句），不要用 ## 大标题和表格
+- 不要罗列每个文件/目录，只说关键信息
+- 中文输出`;
+
+const ANALYZE_PROMPT_EN = `Analyze this project directory and generate a brief Markdown project description.
+
+Read package.json, README.md and other key files, then summarize:
+
+**Tech Stack:** One sentence listing primary languages, frameworks, and key libraries
+**Overview:** One sentence describing what this project is
+**Core Modules:** 2-3 key modules, one sentence each
+
+Requirements:
+- Keep it under 1000 words
+- Use concise Markdown (bold labels + short sentences), no ## headings or tables
+- Don't list every file/directory, only key information
+- Output in English`;
+
+export async function analyzeProjectDirectory(localPath: string, locale: string = "zh"): Promise<string> {
+  if (!localPath || typeof localPath !== "string") {
+    throw new Error("无效的本地路径");
+  }
+  if (localPath.startsWith("~")) {
+    throw new Error("不支持 ~ 别名，请提供绝对路径");
+  }
+  if (!path.isAbsolute(localPath)) {
+    throw new Error("本地路径必须为绝对路径");
+  }
+
+  const prompt = locale === "en" ? ANALYZE_PROMPT_EN : ANALYZE_PROMPT_ZH;
+
+  const { aiQuery } = await import("@/lib/claude-session");
+  const result = await aiQuery(prompt, localPath, {
+    maxTurns: 10,
+    tools: ["Read", "Glob"],
+    allowedTools: ["Read", "Glob"],
+  });
+  if (!result) throw new Error("AI 分析未返回结果");
+  // Hard cap — prompt says 400 words but Claude may exceed
+  return result.length > 2000 ? result.slice(0, 2000).trimEnd() + "\n\n..." : result;
+}

package/src/actions/prompt-actions.ts

@@ -0,0 +1,73 @@
+"use server";
+
+import { db } from "@/lib/db";
+import { revalidatePath } from "next/cache";
+
+export async function getPrompts(workspaceId?: string) {
+  return db.agentPrompt.findMany({
+    where: workspaceId
+      ? { OR: [{ workspaceId }, { workspaceId: null }] }
+      : {},
+    orderBy: [{ isDefault: "desc" }, { name: "asc" }],
+  });
+}
+
+export async function getPromptById(id: string) {
+  return db.agentPrompt.findUnique({ where: { id } });
+}
+
+const MAX_PROMPT_CONTENT_LENGTH = 100_000;
+
+export async function createPrompt(data: {
+  name: string;
+  description?: string;
+  content: string;
+  isDefault?: boolean;
+  workspaceId?: string;
+}) {
+  if (data.content.length > MAX_PROMPT_CONTENT_LENGTH) {
+    throw new Error(`Prompt content exceeds maximum length of ${MAX_PROMPT_CONTENT_LENGTH} characters`);
+  }
+  const prompt = await db.agentPrompt.create({ data });
+  revalidatePath("/workspaces");
+  revalidatePath("/settings");
+  return prompt;
+}
+
+export async function updatePrompt(
+  id: string,
+  data: { name?: string; description?: string; content?: string; isDefault?: boolean }
+) {
+  if (data.content !== undefined && data.content.length > MAX_PROMPT_CONTENT_LENGTH) {
+    throw new Error(`Prompt content exceeds maximum length of ${MAX_PROMPT_CONTENT_LENGTH} characters`);
+  }
+  const prompt = await db.agentPrompt.update({ where: { id }, data });
+  revalidatePath("/workspaces");
+  revalidatePath("/settings");
+  return prompt;
+}
+
+export async function deletePrompt(id: string) {
+  await db.agentPrompt.delete({ where: { id } });
+  revalidatePath("/workspaces");
+  revalidatePath("/settings");
+}
+
+export async function setDefaultPrompt(promptId: string, workspaceId?: string) {
+  const prompt = await db.$transaction(async (tx) => {
+    const whereClause = workspaceId
+      ? { workspaceId, isDefault: true }
+      : { isDefault: true };
+    await tx.agentPrompt.updateMany({
+      where: whereClause,
+      data: { isDefault: false },
+    });
+    return tx.agentPrompt.update({
+      where: { id: promptId },
+      data: { isDefault: true },
+    });
+  });
+  revalidatePath("/workspaces");
+  revalidatePath("/settings");
+  return prompt;
+}

package/src/actions/report-actions.ts

@@ -0,0 +1,141 @@
+"use server";
+
+import { db } from "@/lib/db";
+
+const PRIORITY_ORDER: Record<string, number> = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
+
+export async function getDailySummary(dateStr?: string) {
+  const date = dateStr ? new Date(dateStr + "T00:00:00") : new Date();
+  date.setHours(0, 0, 0, 0);
+  const nextDay = new Date(date);
+  nextDay.setDate(nextDay.getDate() + 1);
+
+  const tasks = await db.task.findMany({
+    where: {
+      OR: [
+        { updatedAt: { gte: date, lt: nextDay } },
+        { executions: { some: { startedAt: { gte: date, lt: nextDay } } } },
+        { messages: { some: { createdAt: { gte: date, lt: nextDay } } } },
+      ],
+    },
+    include: {
+      project: { include: { workspace: true } },
+      messages: {
+        where: { role: "ASSISTANT", createdAt: { gte: date, lt: nextDay } },
+        orderBy: { createdAt: "desc" },
+        take: 1,
+        select: { content: true, createdAt: true },
+      },
+      executions: {
+        where: { startedAt: { gte: date, lt: nextDay } },
+        orderBy: { startedAt: "desc" },
+        take: 1,
+        select: { startedAt: true, status: true, summary: true },
+      },
+    },
+    orderBy: { updatedAt: "desc" },
+  });
+
+  type CompletedTask = { id: string; title: string; priority: string; completedAt: string };
+  type InProgressTask = { id: string; title: string; status: string; priority: string; lastActivity: string; progressSummary: string | null };
+
+  const wsMap = new Map<string, { id: string; name: string; projects: Map<string, { id: string; name: string; alias: string | null; completed: CompletedTask[]; inProgress: InProgressTask[] }> }>();
+
+  for (const task of tasks) {
+    const ws = task.project.workspace;
+    if (!wsMap.has(ws.id)) wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
+    const projMap = wsMap.get(ws.id)!.projects;
+    const proj = task.project;
+    if (!projMap.has(proj.id)) projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, completed: [], inProgress: [] });
+    const projEntry = projMap.get(proj.id)!;
+
+    if (task.status === "DONE") {
+      projEntry.completed.push({ id: task.id, title: task.title, priority: task.priority, completedAt: task.updatedAt.toISOString() });
+    } else if (task.status !== "CANCELLED") {
+      projEntry.inProgress.push({
+        id: task.id, title: task.title, status: task.status, priority: task.priority,
+        lastActivity: (task.messages[0]?.createdAt ?? task.updatedAt).toISOString(),
+        progressSummary: task.executions[0]?.summary
+          ?? (task.messages[0]?.content ? task.messages[0].content.slice(0, 200) + (task.messages[0].content.length > 200 ? "..." : "") : null),
+      });
+    }
+  }
+
+  let totalCompleted = 0;
+  let totalInProgress = 0;
+  const workspaces = Array.from(wsMap.values()).map((ws) => ({
+    id: ws.id, name: ws.name,
+    projects: Array.from(ws.projects.values()).map((p) => {
+      totalCompleted += p.completed.length;
+      totalInProgress += p.inProgress.length;
+      return { id: p.id, name: p.name, alias: p.alias, completed: p.completed, inProgress: p.inProgress };
+    }),
+  }));
+
+  return { date: date.toISOString().slice(0, 10), workspaces, stats: { totalCompleted, totalInProgress, totalActive: totalCompleted + totalInProgress } };
+}
+
+export async function getDailyTodo(filters?: {
+  workspaceId?: string;
+  projectId?: string;
+  status?: ("TODO" | "IN_PROGRESS" | "IN_REVIEW")[];
+  priority?: ("LOW" | "MEDIUM" | "HIGH" | "CRITICAL")[];
+}) {
+  const statusFilter = filters?.status ?? ["TODO", "IN_PROGRESS", "IN_REVIEW"];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const where: any = { status: { in: statusFilter } };
+  if (filters?.priority) where.priority = { in: filters.priority };
+  if (filters?.projectId) where.projectId = filters.projectId;
+  if (filters?.workspaceId) where.project = { workspaceId: filters.workspaceId };
+
+  const tasks = await db.task.findMany({
+    where,
+    include: {
+      project: { include: { workspace: true } },
+      labels: { include: { label: true } },
+      executions: {
+        where: { sessionId: { not: null } },
+        orderBy: { createdAt: "desc" },
+        take: 1,
+        select: { sessionId: true },
+      },
+    },
+  });
+
+  // Sort by priority severity (CRITICAL first), then updatedAt desc
+  tasks.sort((a, b) =>
+    (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99)
+    || b.updatedAt.getTime() - a.updatedAt.getTime()
+  );
+
+  const wsMap = new Map<string, { id: string; name: string; projects: Map<string, { id: string; name: string; alias: string | null; tasks: { id: string; title: string; status: string; priority: string; labels: string[]; createdAt: string; lastSessionId: string | null }[] }> }>();
+
+  for (const task of tasks) {
+    const ws = task.project.workspace;
+    if (!wsMap.has(ws.id)) wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
+    const projMap = wsMap.get(ws.id)!.projects;
+    const proj = task.project;
+    if (!projMap.has(proj.id)) projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, tasks: [] });
+    projMap.get(proj.id)!.tasks.push({
+      id: task.id, title: task.title, status: task.status, priority: task.priority,
+      labels: task.labels.map((tl) => tl.label.name),
+      createdAt: task.createdAt.toISOString(), lastSessionId: task.executions[0]?.sessionId ?? null,
+    });
+  }
+
+  const byStatus = { TODO: 0, IN_PROGRESS: 0, IN_REVIEW: 0 };
+  const byPriority = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
+  for (const t of tasks) {
+    if (t.status in byStatus) byStatus[t.status as keyof typeof byStatus]++;
+    if (t.priority in byPriority) byPriority[t.priority as keyof typeof byPriority]++;
+  }
+
+  return {
+    date: new Date().toISOString().slice(0, 10),
+    workspaces: Array.from(wsMap.values()).map((ws) => ({
+      id: ws.id, name: ws.name,
+      projects: Array.from(ws.projects.values()).map((p) => ({ id: p.id, name: p.name, alias: p.alias, tasks: p.tasks })),
+    })),
+    stats: { total: tasks.length, byStatus, byPriority },
+  };
+}

package/src/actions/search-actions.ts

@@ -0,0 +1,21 @@
+"use server";
+
+import { search } from "@/lib/search";
+import type { SearchResult, SearchCategory } from "@/lib/search";
+import { getConfigValues } from "@/actions/config-actions";
+
+export async function globalSearch(
+  query: string,
+  category: SearchCategory = "task"
+): Promise<SearchResult[]> {
+  const cfg = await getConfigValues([
+    "search.resultLimit",
+    "search.allModeCap",
+    "search.snippetLength",
+  ]);
+  return search(query, category, {
+    resultLimit: (cfg["search.resultLimit"] as number) ?? 20,
+    allModeCap: (cfg["search.allModeCap"] as number) ?? 5,
+    snippetLength: (cfg["search.snippetLength"] as number) ?? 80,
+  });
+}

package/src/actions/search-code-actions.ts

@@ -0,0 +1,185 @@
+"use server";
+
+import { execFile } from "child_process";
+import { z } from "zod";
+import { rgPath } from "@vscode/ripgrep";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface SearchMatch {
+  filePath: string;
+  lineNumber: number;
+  lineText: string;
+  submatches: Array<{ start: number; end: number }>;
+}
+
+export interface SearchResult {
+  matches: SearchMatch[];
+  truncated: boolean;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Zod schema
+// ---------------------------------------------------------------------------
+
+const searchCodeSchema = z.object({
+  localPath: z.string().min(1),
+  pattern: z.string().min(1).max(500),
+  glob: z.string().max(200).optional(),
+  maxResults: z.number().int().min(1).max(500).default(200),
+});
+
+// ---------------------------------------------------------------------------
+// rg JSON output types
+// ---------------------------------------------------------------------------
+
+interface RgMatchData {
+  path: { text: string };
+  lines: { text: string };
+  line_number: number;
+  absolute_offset: number;
+  submatches: Array<{ match: { text: string }; start: number; end: number }>;
+}
+
+interface RgLine {
+  type: string;
+  data: RgMatchData;
+}
+
+// ---------------------------------------------------------------------------
+// Async execFile helper
+// ---------------------------------------------------------------------------
+
+function execFileAsync(
+  cmd: string,
+  args: string[],
+  opts: { encoding: string; maxBuffer?: number; stdio?: unknown; timeout?: number }
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, opts as Parameters<typeof execFile>[2], (err: Error | null, stdout: string | Buffer) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(typeof stdout === "string" ? stdout : stdout.toString());
+      }
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// searchCode server action
+// ---------------------------------------------------------------------------
+
+export async function searchCode(
+  localPath: string,
+  pattern: string,
+  glob?: string,
+  maxResults: number = 200
+): Promise<SearchResult> {
+  // 1. Validate inputs with Zod
+  const parsed = searchCodeSchema.safeParse({ localPath, pattern, glob, maxResults });
+  if (!parsed.success) {
+    return {
+      matches: [],
+      truncated: false,
+      error: `Invalid input: ${parsed.error.message}`,
+    };
+  }
+
+  const {
+    localPath: safePath,
+    pattern: safePattern,
+    glob: safeGlob,
+    maxResults: safeMaxResults,
+  } = parsed.data;
+
+  // 2. Guard: localPath must be absolute (Unix: /path, Windows: C:\path)
+  const isAbsolute = safePath.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(safePath);
+  if (!isAbsolute) {
+    return {
+      matches: [],
+      truncated: false,
+      error: "localPath must be an absolute path",
+    };
+  }
+
+  // 3. Build rg args (using bundled @vscode/ripgrep binary)
+  const args: string[] = ["--json", "-n", safePattern];
+  if (safeGlob) {
+    args.push("--glob", safeGlob);
+  }
+  args.push(safePath);
+
+  // 5. Run rg (async — does not block event loop)
+  let output: string;
+  try {
+    output = await execFileAsync(rgPath, args, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 10_000,
+    });
+  } catch (err) {
+    const rgErr = err as { code?: number; message?: string };
+    // exit code 1 = no matches (not an error)
+    if (rgErr.code === 1) {
+      return { matches: [], truncated: false };
+    }
+    // any other exit code is an actual error — sanitize message
+    console.error("[searchCode] rg failed:", err);
+    return {
+      matches: [],
+      truncated: false,
+      error: "搜索失败，请重试",
+    };
+  }
+
+  // 6. Parse output: split by "\n", JSON.parse each line, filter type==="match"
+  const lines = output.split("\n");
+  const matches: SearchMatch[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let parsedLine: RgLine;
+    try {
+      parsedLine = JSON.parse(trimmed) as RgLine;
+    } catch {
+      continue;
+    }
+
+    if (parsedLine.type !== "match") continue;
+
+    const data = parsedLine.data;
+
+    // 7. Build SearchMatch — strip localPath prefix for relative filePath
+    const absoluteFilePath = data.path.text;
+    const prefix = safePath.endsWith("/") ? safePath : safePath + "/";
+    const filePath = absoluteFilePath.startsWith(prefix)
+      ? absoluteFilePath.slice(prefix.length)
+      : absoluteFilePath;
+
+    const lineText = data.lines.text.replace(/\r?\n$/, "");
+
+    const submatches = data.submatches.map((sm) => ({
+      start: sm.start,
+      end: sm.end,
+    }));
+
+    matches.push({
+      filePath,
+      lineNumber: data.line_number,
+      lineText,
+      submatches,
+    });
+  }
+
+  // 8. Truncate at maxResults
+  const truncated = matches.length > safeMaxResults;
+  const finalMatches = truncated ? matches.slice(0, safeMaxResults) : matches;
+
+  return { matches: finalMatches, truncated };
+}