tower-studio 0.1.2 → 0.1.5

package/.next/standalone/tower/src/actions/project-actions.ts

@@ -1,222 +0,0 @@
-"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/.next/standalone/tower/src/actions/prompt-actions.ts

@@ -1,73 +0,0 @@
-"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/.next/standalone/tower/src/actions/report-actions.ts

@@ -1,141 +0,0 @@
-"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/.next/standalone/tower/src/actions/search-actions.ts

@@ -1,21 +0,0 @@
-"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/.next/standalone/tower/src/actions/search-code-actions.ts

@@ -1,185 +0,0 @@
-"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 };
-}