tower-studio 0.1.1 → 0.1.3

package/src/lib/search.ts

@@ -0,0 +1,225 @@
+// src/lib/search.ts — NO "use server", NO Next.js imports, NO config-actions imports
+// Framework-agnostic shared search module — safe for both Next.js server actions and MCP tools.
+
+import { db } from "@/lib/db";
+
+export type SearchCategory = "task" | "project" | "repository" | "note" | "asset" | "all";
+
+export type SearchResultType = "task" | "project" | "repository" | "note" | "asset";
+
+export interface SearchResult {
+  id: string;
+  type: SearchResultType;
+  title: string;
+  subtitle: string;
+  navigateTo: string;
+  snippet?: string;
+}
+
+export interface SearchConfig {
+  resultLimit: number;
+  allModeCap: number;
+  snippetLength: number;
+}
+
+interface NoteRawRow {
+  note_id: string;
+  title: string;
+  content: string;
+  projectId: string;
+  workspaceId: string;
+  project_name: string;
+  workspace_name: string;
+}
+
+function toNoteResult(row: NoteRawRow, snippetLength: number): SearchResult {
+  return {
+    id: row.note_id,
+    type: "note" as const,
+    title: row.title,
+    subtitle: `${row.workspace_name} / ${row.project_name}`,
+    navigateTo: `/workspaces/${row.workspaceId}/notes?projectId=${row.projectId}`,
+    snippet: row.content ? row.content.slice(0, snippetLength) : undefined,
+  };
+}
+
+export async function search(
+  query: string,
+  category: SearchCategory = "task",
+  config: SearchConfig
+): Promise<SearchResult[]> {
+  if (!query.trim()) return [];
+  const q = query.trim();
+
+  const { resultLimit, allModeCap, snippetLength } = config;
+
+  if (category === "all") {
+    const [taskRes, projectRes, repoRes, noteRes, assetRes] = await Promise.allSettled([
+      search(q, "task", config),
+      search(q, "project", config),
+      search(q, "repository", config),
+      search(q, "note", config),
+      search(q, "asset", config),
+    ]);
+    const collect = (res: PromiseSettledResult<SearchResult[]>) =>
+      res.status === "fulfilled" ? res.value.slice(0, allModeCap) : [];
+    return [
+      ...collect(taskRes),
+      ...collect(projectRes),
+      ...collect(repoRes),
+      ...collect(noteRes),
+      ...collect(assetRes),
+    ];
+  }
+
+  if (category === "task") {
+    const tasks = await db.task.findMany({
+      where: {
+        OR: [
+          { title: { contains: q } },
+          { description: { contains: q } },
+        ],
+      },
+      include: {
+        project: {
+          include: { workspace: true },
+        },
+      },
+      take: resultLimit,
+      orderBy: { updatedAt: "desc" },
+    });
+    return tasks.map((t) => ({
+      id: t.id,
+      type: "task" as const,
+      title: t.title,
+      subtitle: `${t.project.workspace.name} / ${t.project.name}`,
+      navigateTo: `/workspaces/${t.project.workspaceId}?projectId=${t.projectId}`,
+    }));
+  }
+
+  if (category === "project") {
+    const projects = await db.project.findMany({
+      where: {
+        OR: [
+          { name: { contains: q } },
+          { alias: { contains: q } },
+          { description: { contains: q } },
+        ],
+      },
+      include: { workspace: true },
+      take: resultLimit,
+      orderBy: { updatedAt: "desc" },
+    });
+    return projects.map((p) => ({
+      id: p.id,
+      type: "project" as const,
+      title: p.alias ? `${p.name} (${p.alias})` : p.name,
+      subtitle: p.workspace.name,
+      navigateTo: `/workspaces/${p.workspaceId}?projectId=${p.id}`,
+    }));
+  }
+
+  if (category === "repository") {
+    const repos = await db.repository.findMany({
+      where: {
+        OR: [
+          { name: { contains: q } },
+          { path: { contains: q } },
+        ],
+      },
+      include: {
+        project: {
+          include: { workspace: true },
+        },
+      },
+      take: resultLimit,
+    });
+    return repos.map((r) => ({
+      id: r.id,
+      type: "repository" as const,
+      title: r.name,
+      subtitle: `${r.project.workspace.name} / ${r.project.name} · ${r.branch}`,
+      navigateTo: `/workspaces/${r.project.workspaceId}?projectId=${r.projectId}`,
+    }));
+  }
+
+  if (category === "note") {
+    // Short query fallback (< 3 chars): FTS5 trigram needs 3+ chars
+    if (q.length < 3) {
+      const rows = await db.$queryRawUnsafe<NoteRawRow[]>(
+        `SELECT n.id as note_id, n.title, n.content,
+                n."projectId", p."workspaceId", p.name as project_name, w.name as workspace_name
+         FROM "ProjectNote" n
+         JOIN "Project" p ON p.id = n."projectId"
+         JOIN "Workspace" w ON w.id = p."workspaceId"
+         WHERE n.title LIKE ? OR n.content LIKE ?
+         LIMIT ?`,
+        `%${q}%`,
+        `%${q}%`,
+        resultLimit
+      );
+      return rows.map((row) => toNoteResult(row, snippetLength));
+    }
+
+    // FTS5 search — catch malformed query and fall back to LIKE
+    try {
+      const rows = await db.$queryRawUnsafe<NoteRawRow[]>(
+        `SELECT f.note_id, f.title, f.content,
+                n."projectId", p."workspaceId", p.name as project_name, w.name as workspace_name
+         FROM notes_fts f
+         JOIN "ProjectNote" n ON n.id = f.note_id
+         JOIN "Project" p ON p.id = n."projectId"
+         JOIN "Workspace" w ON w.id = p."workspaceId"
+         WHERE f.notes_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`,
+        q,
+        resultLimit
+      );
+      return rows.map((row) => toNoteResult(row, snippetLength));
+    } catch {
+      // Malformed FTS5 query (e.g., unmatched quotes) — fall back to LIKE
+      const rows = await db.$queryRawUnsafe<NoteRawRow[]>(
+        `SELECT n.id as note_id, n.title, n.content,
+                n."projectId", p."workspaceId", p.name as project_name, w.name as workspace_name
+         FROM "ProjectNote" n
+         JOIN "Project" p ON p.id = n."projectId"
+         JOIN "Workspace" w ON w.id = p."workspaceId"
+         WHERE n.title LIKE ? OR n.content LIKE ?
+         LIMIT ?`,
+        `%${q}%`,
+        `%${q}%`,
+        resultLimit
+      );
+      return rows.map((row) => toNoteResult(row, snippetLength));
+    }
+  }
+
+  if (category === "asset") {
+    const assets = await db.projectAsset.findMany({
+      where: {
+        OR: [
+          { filename: { contains: q } },
+          { description: { contains: q } },
+        ],
+      },
+      include: {
+        project: {
+          include: { workspace: true },
+        },
+      },
+      take: resultLimit,
+      orderBy: { createdAt: "desc" },
+    });
+    return assets.map((a) => ({
+      id: a.id,
+      type: "asset" as const,
+      title: a.filename,
+      subtitle: `${a.project.workspace.name} / ${a.project.name}`,
+      navigateTo: `/workspaces/${a.project.workspaceId}/assets?projectId=${a.projectId}`,
+      snippet: a.description || undefined,
+    }));
+  }
+
+  return [];
+}

package/src/lib/terminal-link-provider.ts

@@ -0,0 +1,90 @@
+import type { Terminal, ILinkProvider, ILink, IBufferLine } from "@xterm/xterm";
+
+/** A detected file link with path, position, and line/col info. */
+export interface ParsedFileLink {
+  path: string;
+  startIndex: number;
+  totalLength: number;
+  line?: number;
+  col?: number;
+}
+
+// Match relative file paths: ./foo.ts | src/foo.ts | foo/bar.tsx
+const FILE_PATH_RE =
+  /(?:\.\.?\/|[a-zA-Z0-9_@][a-zA-Z0-9_\-.]*\/)[a-zA-Z0-9_\-.\/@]+\.\w+/g;
+
+// Line/col suffix: :line:col | (line,col) | [line, col]
+const SUFFIX_RE =
+  /^(?::(\d+)(?::(\d+))?|\((\d+)(?:,\s*(\d+))?\)|\[(\d+)(?:,\s*(\d+))?\])/;
+
+/** Parse file path links from a single line of terminal text. */
+export function parseFileLinks(text: string): ParsedFileLink[] {
+  const links: ParsedFileLink[] = [];
+  FILE_PATH_RE.lastIndex = 0;
+
+  let match: RegExpExecArray | null;
+  while ((match = FILE_PATH_RE.exec(text)) !== null) {
+    const pathStr = match[0];
+    const startIndex = match.index;
+
+    const afterPath = text.slice(startIndex + pathStr.length);
+    const suffixMatch = afterPath.match(SUFFIX_RE);
+
+    let totalLength = pathStr.length;
+    let fileLine: number | undefined;
+    let fileCol: number | undefined;
+
+    if (suffixMatch && suffixMatch.index === 0) {
+      totalLength += suffixMatch[0].length;
+      const rawLine = suffixMatch[1] ?? suffixMatch[3] ?? suffixMatch[5];
+      const rawCol = suffixMatch[2] ?? suffixMatch[4] ?? suffixMatch[6];
+      fileLine = rawLine ? parseInt(rawLine, 10) : undefined;
+      fileCol = rawCol ? parseInt(rawCol, 10) : undefined;
+    }
+
+    links.push({ path: pathStr, startIndex, totalLength, line: fileLine, col: fileCol });
+  }
+
+  return links;
+}
+
+/**
+ * Local file link provider for xterm.js terminals.
+ *
+ * Detects file paths in terminal output (e.g. src/foo.ts:42:10)
+ * and makes them clickable, opening the file in the workbench editor.
+ */
+export class LocalFileLinkProvider implements ILinkProvider {
+  constructor(
+    private terminal: Terminal,
+    private worktreePath: string,
+    private onFileOpen: (fullPath: string, line?: number, col?: number) => void,
+  ) {}
+
+  provideLinks(
+    lineNumber: number,
+    callback: (links: ILink[] | undefined) => void,
+  ): void {
+    const bufferLine: IBufferLine | undefined =
+      this.terminal.buffer.active.getLine(lineNumber);
+    if (!bufferLine) return callback(undefined);
+
+    const text = bufferLine.translateToString();
+    const parsed = parseFileLinks(text);
+
+    if (parsed.length === 0) return callback(undefined);
+
+    const links: ILink[] = parsed.map((p) => ({
+      range: {
+        start: { x: p.startIndex + 1, y: lineNumber },
+        end: { x: p.startIndex + p.totalLength + 1, y: lineNumber },
+      },
+      text: text.slice(p.startIndex, p.startIndex + p.totalLength),
+      activate: () => {
+        this.onFileOpen(`${this.worktreePath}/${p.path}`, p.line, p.col);
+      },
+    }));
+
+    callback(links);
+  }
+}

package/src/lib/tower-dir.ts

@@ -0,0 +1,69 @@
+/**
+ * Canonical Tower data directory: ~/.tower
+ *
+ * All runtime data lives here, independent of where the app is installed.
+ *
+ * Structure:
+ *   ~/.tower/
+ *   ├── database/            # SQLite database
+ *   │   └── tower.db
+ *   ├── storage/             # User file storage
+ *   │   ├── assets/          #   Project assets (uploads)
+ *   │   │   └── <projectId>/
+ *   │   └── cache/           #   Runtime cache
+ *   │       ├── <taskId>/
+ *   │       └── assistant/   #   AI assistant chat images
+ *   ├── assistant/           # AI assistant config
+ *   │   ├── CLAUDE.md
+ *   │   └── .claude/skills/
+ *   └── logs/                # Logs (reserved)
+ */
+
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { mkdirSync, existsSync } from "node:fs";
+
+let _dir: string | undefined;
+
+/** ~/.tower */
+export function getTowerDir(): string {
+  if (_dir) return _dir;
+  _dir = join(homedir(), ".tower");
+  if (!existsSync(_dir)) {
+    mkdirSync(_dir, { recursive: true });
+  }
+  return _dir;
+}
+
+/** ~/.tower/database */
+export function getDatabaseDir(): string {
+  const dir = join(getTowerDir(), "database");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** ~/.tower/database/tower.db */
+export function getTowerDbPath(): string {
+  return join(getDatabaseDir(), "tower.db");
+}
+
+/** ~/.tower/storage — root for assets + cache */
+export function getStorageDir(): string {
+  const dir = join(getTowerDir(), "storage");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** ~/.tower/assistant */
+export function getAssistantDir(): string {
+  const dir = join(getTowerDir(), "assistant");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** ~/.tower/logs */
+export function getLogsDir(): string {
+  const dir = join(getTowerDir(), "logs");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}

package/src/lib/utils.ts

@@ -0,0 +1,20 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export function formatRelativeTime(date: Date): string {
+  const now = Date.now();
+  const diff = now - date.getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+
+  if (minutes < 1) return "刚刚";
+  if (minutes < 60) return `${minutes}分钟前`;
+  if (hours < 24) return `${hours}小时前`;
+  if (days < 30) return `${days}天前`;
+  return date.toLocaleDateString("zh-CN");
+}

package/src/lib/worktree.ts

@@ -0,0 +1,184 @@
+import { execFileSync } from "child_process";
+import { existsSync, symlinkSync, lstatSync } from "fs";
+import { mkdir } from "fs/promises";
+import path from "path";
+import os from "os";
+import { logger } from "@/lib/logger";
+
+function expandHome(p: string): string {
+  if (p.startsWith("~/") || p === "~") {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+
+export interface WorktreeResult {
+  worktreePath: string;
+  worktreeBranch: string;
+}
+
+/**
+ * Creates a git worktree for the given task, or reuses one if it already exists.
+ *
+ * @param localPath  - Absolute path to the project root (git repo)
+ * @param taskId     - The task ID (used to derive worktree path and branch name)
+ * @param baseBranch - The branch to base the new task branch on
+ * @returns WorktreeResult with the worktree path and branch name
+ * @throws If git worktree add fails with a non-recoverable error
+ */
+export async function createWorktree(
+  localPathRaw: string,
+  taskId: string,
+  baseBranch: string
+): Promise<WorktreeResult> {
+  const localPath = expandHome(localPathRaw);
+  const worktreePath = path.join(localPath, ".worktrees", "task-" + taskId);
+  const worktreeBranch = "task/" + taskId;
+
+  // Ensure .worktrees directory exists
+  await mkdir(path.join(localPath, ".worktrees"), { recursive: true });
+
+  // Check if worktree already exists (reuse case)
+  const worktreeList = execFileSync(
+    "git", ["worktree", "list", "--porcelain"],
+    { cwd: localPath, encoding: "utf-8", timeout: 10000 }
+  );
+
+  // Normalize paths for cross-platform comparison (Windows may have mixed slashes)
+  const normalizedWorktreePath = path.normalize(worktreePath).replace(/\\/g, "/");
+  const worktreeLines = worktreeList.split("\n");
+  const alreadyExists = worktreeLines.some(
+    (line: string) => line.startsWith("worktree ") &&
+      line.slice(9).replace(/\\/g, "/") === normalizedWorktreePath
+  );
+
+  if (alreadyExists) {
+    return { worktreePath, worktreeBranch };
+  }
+
+  // Additional check: if directory exists but not in git worktree list, clean it up first
+  if (existsSync(worktreePath)) {
+    logger.warn(`[worktree] Directory exists but not tracked by git, removing: ${worktreePath}`);
+    execFileSync(
+      "git", ["worktree", "remove", worktreePath, "--force"],
+      { cwd: localPath, encoding: "utf-8", timeout: 30000 }
+    );
+  }
+
+  // Check if the task branch already exists
+  const branchList = execFileSync(
+    "git", ["branch", "--list", worktreeBranch],
+    { cwd: localPath, encoding: "utf-8", timeout: 5000 }
+  ).trim();
+
+  if (branchList) {
+    // Branch exists: attach existing branch without -b flag (preserves previous work)
+    execFileSync(
+      "git", ["worktree", "add", worktreePath, worktreeBranch],
+      { cwd: localPath, encoding: "utf-8", timeout: 30000 }
+    );
+  } else {
+    // Resolve baseBranch — try local first, then remote (origin/xxx)
+    let resolvedBase = baseBranch;
+    try {
+      execFileSync("git", ["rev-parse", "--verify", baseBranch], { cwd: localPath, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+    } catch {
+      // Local branch doesn't exist — try as remote tracking branch
+      try {
+        execFileSync("git", ["rev-parse", "--verify", `origin/${baseBranch}`], { cwd: localPath, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        resolvedBase = `origin/${baseBranch}`;
+      } catch {
+        throw new Error(
+          `Base branch '${baseBranch}' does not exist locally or on remote. Available branches: ` +
+          execFileSync("git", ["branch", "-a", "--format=%(refname:short)"], { cwd: localPath, encoding: "utf-8", timeout: 5000 }).trim().split("\n").join(", ")
+        );
+      }
+    }
+
+    // Branch does not exist: create new branch from resolved base
+    execFileSync(
+      "git", ["worktree", "add", "-b", worktreeBranch, worktreePath, resolvedBase],
+      { cwd: localPath, encoding: "utf-8", timeout: 30000 }
+    );
+  }
+
+  // Symlink node_modules from main project to worktree (avoids reinstalling deps)
+  symlinkNodeModules(localPath, worktreePath);
+
+  return { worktreePath, worktreeBranch };
+}
+
+/**
+ * Creates a symlink for node_modules (and other common dependency dirs) from
+ * the main project to the worktree directory. This avoids requiring users to
+ * reinstall dependencies in every worktree.
+ *
+ * Only creates symlinks for directories that exist in the source and do NOT
+ * already exist in the target.
+ */
+function symlinkNodeModules(projectRoot: string, worktreePath: string): void {
+  const log = logger.create("worktree");
+  // Common dependency directories that should be shared
+  const dirs = ["node_modules", ".next"];
+
+  for (const dir of dirs) {
+    const source = path.join(projectRoot, dir);
+    const target = path.join(worktreePath, dir);
+
+    if (!existsSync(source)) continue;
+
+    // Skip if target already exists (real dir or existing symlink)
+    try {
+      lstatSync(target);
+      continue; // exists — don't overwrite
+    } catch {
+      // Does not exist — proceed to create symlink
+    }
+
+    try {
+      symlinkSync(source, target, "junction"); // "junction" works on Windows too
+      log.info(`Symlinked ${dir}`, { from: source, to: target });
+    } catch (err) {
+      log.warn(`Failed to symlink ${dir}`, { error: String(err) });
+    }
+  }
+}
+
+/**
+ * Removes a git worktree and its associated task branch.
+ *
+ * Best-effort: skips steps that are already done (missing dir or branch).
+ * Callers should wrap in try/catch — this function may throw on git errors.
+ *
+ * @param localPath - Absolute path to the project root (git repo)
+ * @param taskId    - The task ID (used to derive worktree path and branch name)
+ */
+export async function removeWorktree(
+  localPathRaw: string,
+  taskId: string
+): Promise<void> {
+  const localPath = expandHome(localPathRaw);
+  const worktreePath = path.join(localPath, ".worktrees", "task-" + taskId);
+  const worktreeBranch = "task/" + taskId;
+
+  // D-11: Only remove worktree dir if it exists
+  if (existsSync(worktreePath)) {
+    execFileSync(
+      "git", ["worktree", "remove", worktreePath, "--force"],
+      { cwd: localPath, encoding: "utf-8", timeout: 30000 }
+    );
+  }
+
+  // D-12: Only delete branch if it exists
+  const branchExists = execFileSync(
+    "git", ["branch", "--list", worktreeBranch],
+    { cwd: localPath, encoding: "utf-8", timeout: 5000 }
+  ).trim();
+
+  if (branchExists) {
+    execFileSync(
+      "git", ["branch", "-D", worktreeBranch],
+      { cwd: localPath, encoding: "utf-8", timeout: 5000 }
+    );
+  }
+}

package/src/stores/board-store.ts

@@ -0,0 +1,46 @@
+import { create } from "zustand";
+import type { Task, TaskStatus } from "@prisma/client";
+
+type FilterType = "ALL" | "IN_PROGRESS" | "IN_REVIEW";
+
+interface BoardState {
+  tasks: Task[];
+  filter: FilterType;
+  selectedTaskId: string | null;
+  setTasks: (tasks: Task[]) => void;
+  setFilter: (filter: FilterType) => void;
+  setSelectedTaskId: (id: string | null) => void;
+  moveTask: (taskId: string, newStatus: TaskStatus) => void;
+  getFilteredTasks: () => Task[];
+  getTasksByStatus: (status: TaskStatus) => Task[];
+}
+
+export const useBoardStore = create<BoardState>((set, get) => ({
+  tasks: [],
+  filter: "ALL",
+  selectedTaskId: null,
+  setTasks: (tasks) => set({ tasks }),
+  setFilter: (filter) => set({ filter }),
+  setSelectedTaskId: (id) => set({ selectedTaskId: id }),
+  moveTask: (taskId, newStatus) =>
+    set((state) => ({
+      tasks: state.tasks.map((t) =>
+        t.id === taskId ? { ...t, status: newStatus } : t
+      ),
+    })),
+  getFilteredTasks: () => {
+    const { tasks, filter } = get();
+    if (filter === "ALL") return tasks;
+    return tasks.filter((t) => t.status === filter);
+  },
+  getTasksByStatus: (status) => {
+    const filtered = get().getFilteredTasks().filter((t) => t.status === status);
+    // For DONE and CANCELLED, only show tasks updated today
+    if (status === "DONE" || status === "CANCELLED") {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      return filtered.filter((t) => new Date(t.updatedAt) >= today);
+    }
+    return filtered;
+  },
+}));

package/src/stores/task-execution-store.ts

@@ -0,0 +1,41 @@
+import { create } from "zustand";
+
+interface ExecutionMessage {
+  id: string;
+  role: "user" | "assistant" | "system";
+  content: string;
+  createdAt: Date;
+}
+
+interface ExecutionState {
+  activeTaskId: string | null;
+  isStreaming: boolean;
+  messages: ExecutionMessage[];
+  fileChanges: { added: number; removed: number };
+  setActiveTask: (taskId: string | null) => void;
+  addMessage: (msg: ExecutionMessage) => void;
+  setMessages: (msgs: ExecutionMessage[]) => void;
+  setStreaming: (streaming: boolean) => void;
+  setFileChanges: (changes: { added: number; removed: number }) => void;
+  reset: () => void;
+}
+
+export const useExecutionStore = create<ExecutionState>((set) => ({
+  activeTaskId: null,
+  isStreaming: false,
+  messages: [],
+  fileChanges: { added: 0, removed: 0 },
+  setActiveTask: (taskId) => set({ activeTaskId: taskId }),
+  addMessage: (msg) =>
+    set((state) => ({ messages: [...state.messages, msg] })),
+  setMessages: (msgs) => set({ messages: msgs }),
+  setStreaming: (streaming) => set({ isStreaming: streaming }),
+  setFileChanges: (changes) => set({ fileChanges: changes }),
+  reset: () =>
+    set({
+      activeTaskId: null,
+      isStreaming: false,
+      messages: [],
+      fileChanges: { added: 0, removed: 0 },
+    }),
+}));