tower-studio 0.1.3 → 0.1.5

package/src/lib/search.ts

@@ -1,225 +0,0 @@
-// 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

@@ -1,90 +0,0 @@
-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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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 },
-    }),
-}));