beads-kanban-ui 0.1.0 → 0.1.1

package/src/lib/beads-parser.ts

@@ -1,252 +0,0 @@
-/**
- * Parser for beads data via HTTP API
- *
- * Fetches and provides typed access to beads with helper functions for
- * common operations.
- */
-
-import * as api from './api';
-import type { Bead, BeadStatus, Epic } from "@/types";
-
-/**
- * Loads beads from a project directory via API
- *
- * @param projectPath - The root path of the project
- * @returns Promise resolving to array of Bead objects
- *
- * @example
- * ```typescript
- * const beads = await loadProjectBeads('/path/to/project');
- * ```
- */
-export async function loadProjectBeads(projectPath: string): Promise<Bead[]> {
-  try {
-    const result = await api.beads.read(projectPath);
-    // Ensure every bead has a comments array (defensive against null/undefined)
-    return result.beads.map((bead) => ({
-      ...bead,
-      comments: bead.comments ?? [],
-    }));
-  } catch (error) {
-    console.error(`Failed to load beads from ${projectPath}:`, error);
-    return [];
-  }
-}
-
-/**
- * Alias for loadProjectBeads for backward compatibility
- */
-export async function parseBeadsFromPath(projectPath: string): Promise<Bead[]> {
-  return loadProjectBeads(projectPath);
-}
-
-/**
- * Groups beads by their status into a record
- *
- * @param beads - Array of Bead objects to group
- * @returns Record with status keys and arrays of beads as values
- *
- * @example
- * ```typescript
- * const grouped = groupBeadsByStatus(beads);
- * console.log(grouped.open.length); // Number of open beads
- * console.log(grouped.closed.length); // Number of closed beads
- * ```
- */
-export function groupBeadsByStatus(beads: Bead[]): Record<BeadStatus, Bead[]> {
-  const grouped: Record<BeadStatus, Bead[]> = {
-    open: [],
-    in_progress: [],
-    inreview: [],
-    closed: [],
-  };
-
-  for (const bead of beads) {
-    grouped[bead.status].push(bead);
-  }
-
-  // Sort each group by updated_at descending (most recent first)
-  for (const status of Object.keys(grouped) as BeadStatus[]) {
-    grouped[status].sort((a, b) => {
-      const dateA = new Date(a.updated_at).getTime();
-      const dateB = new Date(b.updated_at).getTime();
-      return dateB - dateA;
-    });
-  }
-
-  return grouped;
-}
-
-/**
- * Finds a bead by its ID
- *
- * @param beads - Array of Bead objects to search
- * @param id - The bead ID to find
- * @returns The matching Bead or undefined if not found
- *
- * @example
- * ```typescript
- * const bead = getBeadById(beads, 'beads-kanban-ui-323');
- * if (bead) {
- *   console.log(bead.title);
- * }
- * ```
- */
-export function getBeadById(beads: Bead[], id: string): Bead | undefined {
-  return beads.find((bead) => bead.id === id);
-}
-
-/**
- * Constructs the path to issues.jsonl from a project path
- *
- * @param projectPath - The root path of the project
- * @returns Path to the issues.jsonl file
- */
-export function getBeadsFilePath(projectPath: string): string {
-  // Normalize path separators and ensure no trailing slash
-  const normalizedPath = projectPath.replace(/\\/g, "/").replace(/\/$/, "");
-  return `${normalizedPath}/.beads/issues.jsonl`;
-}
-
-/**
- * Assigns sequential ticket numbers to beads based on creation order
- *
- * @param beads - Array of Bead objects to assign numbers to
- * @returns Map of bead ID to ticket number (1-indexed, oldest bead = #1)
- *
- * @example
- * ```typescript
- * const ticketNumbers = assignTicketNumbers(beads);
- * const ticketNum = ticketNumbers.get('beads-kanban-ui-323'); // e.g., 5
- * console.log(`#${ticketNum}`); // "#5"
- * ```
- */
-export function assignTicketNumbers(beads: Bead[]): Map<string, number> {
-  // Sort all beads by created_at ascending (oldest first)
-  const sortedBeads = [...beads].sort((a, b) => {
-    const dateA = new Date(a.created_at).getTime();
-    const dateB = new Date(b.created_at).getTime();
-    return dateA - dateB;
-  });
-
-  // Assign 1-indexed ticket numbers
-  const ticketNumbers = new Map<string, number>();
-  sortedBeads.forEach((bead, index) => {
-    ticketNumbers.set(bead.id, index + 1);
-  });
-
-  return ticketNumbers;
-}
-
-/**
- * Groups beads by epic status for epic-specific views
- *
- * @param beads - Array of Bead objects to group
- * @returns Record with epic status keys (with_children, standalone) and arrays of beads
- *
- * @example
- * ```typescript
- * const grouped = groupByEpicStatus(beads);
- * console.log(grouped.epics.length); // Number of epic beads
- * console.log(grouped.standalone.length); // Number of standalone task beads
- * ```
- */
-export function groupByEpicStatus(beads: Bead[]): {
-  epics: Epic[];
-  standalone: Bead[];
-  children: Bead[];
-} {
-  const epics: Epic[] = [];
-  const standalone: Bead[] = [];
-  const children: Bead[] = [];
-
-  for (const bead of beads) {
-    // Epic: has issue_type 'epic' or has children
-    if (bead.issue_type === 'epic' || (bead.children && bead.children.length > 0)) {
-      epics.push({
-        ...bead,
-        issue_type: 'epic',
-        children: bead.children ?? [],
-      } as Epic);
-    }
-    // Child: has parent_id
-    else if (bead.parent_id) {
-      children.push(bead);
-    }
-    // Standalone: no parent, not an epic
-    else {
-      standalone.push(bead);
-    }
-  }
-
-  return { epics, standalone, children };
-}
-
-/**
- * Gets all child beads for a specific epic
- *
- * @param epicId - The ID of the epic to get children for
- * @param beads - Array of all beads to search
- * @returns Array of child beads belonging to the epic
- *
- * @example
- * ```typescript
- * const children = getEpicChildren('epic-123', allBeads);
- * console.log(`Epic has ${children.length} children`);
- * ```
- */
-export function getEpicChildren(epicId: string, beads: Bead[]): Bead[] {
-  if (!epicId || !beads || beads.length === 0) {
-    return [];
-  }
-
-  // Find the epic first
-  const epic = beads.find((b) => b.id === epicId);
-  if (!epic || !epic.children || epic.children.length === 0) {
-    return [];
-  }
-
-  // Create a lookup map for fast access
-  const beadMap = new Map<string, Bead>();
-  for (const bead of beads) {
-    beadMap.set(bead.id, bead);
-  }
-
-  // Resolve children
-  return epic.children
-    .map((childId) => beadMap.get(childId))
-    .filter((child): child is Bead => child !== undefined);
-}
-
-/**
- * Checks if an epic is completed (all children closed)
- *
- * @param epic - The epic bead to check
- * @param beads - Array of all beads to resolve children from
- * @returns True if all children are closed, false otherwise
- *
- * @example
- * ```typescript
- * if (isEpicCompleted(epic, allBeads)) {
- *   console.log('Epic is fully completed!');
- * }
- * ```
- */
-export function isEpicCompleted(epic: Epic, beads: Bead[]): boolean {
-  if (!epic.children || epic.children.length === 0) {
-    // Epic with no children is considered completed
-    return true;
-  }
-
-  if (!beads || beads.length === 0) {
-    return false;
-  }
-
-  const children = getEpicChildren(epic.id, beads);
-  if (children.length === 0) {
-    return false;
-  }
-
-  // All children must be closed
-  return children.every((child) => child.status === 'closed');
-}

package/src/lib/cli.ts

@@ -1,193 +0,0 @@
-/**
- * CLI wrapper for bd (beads) commands via HTTP API
- *
- * Provides typed async functions for interacting with the bd CLI tool
- * through the backend API.
- */
-
-import * as api from './api';
-import type { BeadStatus } from "@/types";
-
-/**
- * Result from executing a CLI command
- */
-export interface CommandResult {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  code: number | null;
-}
-
-/**
- * Execute a bd CLI command with the given arguments
- *
- * @param args - Array of command arguments (excluding 'bd')
- * @param cwd - Working directory for the command
- * @returns Promise resolving to command result
- */
-async function executeBdCommand(
-  args: string[],
-  cwd?: string
-): Promise<CommandResult> {
-  const result = await api.bd.command(args, cwd);
-
-  return {
-    success: result.code === 0,
-    stdout: result.stdout,
-    stderr: result.stderr,
-    code: result.code,
-  };
-}
-
-/**
- * Add a comment to a bead
- *
- * Executes: bd comment <beadId> "<message>"
- *
- * @param beadId - The ID of the bead to comment on
- * @param message - The comment message
- * @param cwd - Working directory (project path)
- * @throws Error if command fails
- *
- * @example
- * ```typescript
- * await addComment('BD-001', 'Fixed the bug', '/path/to/project');
- * ```
- */
-export async function addComment(
-  beadId: string,
-  message: string,
-  cwd?: string
-): Promise<void> {
-  const result = await executeBdCommand(["comment", beadId, message], cwd);
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to add comment: exit code ${result.code}`);
-  }
-}
-
-/**
- * Update the status of a bead
- *
- * Executes: bd update <beadId> --status <status>
- *
- * @param beadId - The ID of the bead to update
- * @param status - The new status value
- * @param cwd - Working directory (project path)
- * @throws Error if command fails
- *
- * @example
- * ```typescript
- * await updateStatus('BD-001', 'in_progress', '/path/to/project');
- * ```
- */
-export async function updateStatus(
-  beadId: string,
-  status: BeadStatus,
-  cwd?: string
-): Promise<void> {
-  const result = await executeBdCommand(
-    ["update", beadId, "--status", status],
-    cwd
-  );
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to update status: exit code ${result.code}`);
-  }
-}
-
-/**
- * Close a bead
- *
- * Executes: bd close <beadId>
- *
- * @param beadId - The ID of the bead to close
- * @param cwd - Working directory (project path)
- * @throws Error if command fails
- *
- * @example
- * ```typescript
- * await closeBead('BD-001', '/path/to/project');
- * ```
- */
-export async function closeBead(beadId: string, cwd?: string): Promise<void> {
-  const result = await executeBdCommand(["close", beadId], cwd);
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to close bead: exit code ${result.code}`);
-  }
-}
-
-/**
- * Create a new bead
- *
- * Executes: bd create "<title>" -d "<description>"
- *
- * @param title - The bead title
- * @param description - The bead description
- * @param cwd - Working directory (project path)
- * @returns The created bead ID (if parseable from output)
- * @throws Error if command fails
- *
- * @example
- * ```typescript
- * const id = await createBead('Fix bug', 'Bug in login form', '/path/to/project');
- * ```
- */
-export async function createBead(
-  title: string,
-  description: string,
-  cwd?: string
-): Promise<string | null> {
-  const result = await executeBdCommand(
-    ["create", title, "-d", description],
-    cwd
-  );
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to create bead: exit code ${result.code}`);
-  }
-
-  // Try to extract bead ID from output (format varies by CLI version)
-  const idMatch = result.stdout.match(/(?:BD-|bd-)[\w-]+/i);
-  return idMatch ? idMatch[0] : null;
-}
-
-/**
- * Get bead details
- *
- * Executes: bd show <beadId>
- *
- * @param beadId - The ID of the bead to show
- * @param cwd - Working directory (project path)
- * @returns Raw output from bd show command
- * @throws Error if command fails
- */
-export async function showBead(beadId: string, cwd?: string): Promise<string> {
-  const result = await executeBdCommand(["show", beadId], cwd);
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to show bead: exit code ${result.code}`);
-  }
-
-  return result.stdout;
-}
-
-/**
- * List all beads
- *
- * Executes: bd list
- *
- * @param cwd - Working directory (project path)
- * @returns Raw output from bd list command
- * @throws Error if command fails
- */
-export async function listBeads(cwd?: string): Promise<string> {
-  const result = await executeBdCommand(["list"], cwd);
-
-  if (!result.success) {
-    throw new Error(result.stderr || `Failed to list beads: exit code ${result.code}`);
-  }
-
-  return result.stdout;
-}

package/src/lib/db.ts

@@ -1,145 +0,0 @@
-/**
- * Database client for HTTP API operations
- *
- * Provides typed wrappers around API calls for projects, tags,
- * and their relationships.
- */
-
-import * as api from './api';
-import type { Project, Tag } from '@/types';
-
-// ===== Input Types =====
-
-export type { Project, Tag };
-
-export interface CreateProjectInput {
-  name: string;
-  path: string;
-}
-
-export interface UpdateProjectInput {
-  id: string;
-  name?: string;
-  path?: string;
-}
-
-export interface CreateTagInput {
-  name: string;
-  color: string;
-}
-
-export interface UpdateTagInput {
-  id: string;
-  name?: string;
-  color?: string;
-}
-
-// ===== Project Operations =====
-
-/**
- * Gets all projects, ordered by last opened
- */
-export async function getProjects(): Promise<Project[]> {
-  return api.projects.list();
-}
-
-/**
- * Creates a new project
- */
-export async function createProject(input: CreateProjectInput): Promise<Project> {
-  return api.projects.create(input);
-}
-
-/**
- * Updates an existing project
- */
-export async function updateProject(input: UpdateProjectInput): Promise<Project> {
-  const { id, ...data } = input;
-  return api.projects.update(id, data);
-}
-
-/**
- * Deletes a project by ID
- */
-export async function deleteProject(id: string): Promise<void> {
-  return api.projects.delete(id);
-}
-
-// ===== Tag Operations =====
-
-/**
- * Gets all tags
- */
-export async function getTags(): Promise<Tag[]> {
-  return api.tags.list();
-}
-
-/**
- * Creates a new tag
- */
-export async function createTag(input: CreateTagInput): Promise<Tag> {
-  return api.tags.create(input);
-}
-
-/**
- * Updates an existing tag
- */
-export async function updateTag(input: UpdateTagInput): Promise<Tag> {
-  const { id, ...data } = input;
-  // Note: API doesn't have a separate update endpoint, using create for now
-  // This would need backend support for tag updates
-  return api.tags.create(data as CreateTagInput);
-}
-
-/**
- * Deletes a tag by ID
- */
-export async function deleteTag(id: string): Promise<void> {
-  return api.tags.delete(id);
-}
-
-// ===== Project-Tag Relationships =====
-
-/**
- * Gets all tags for a specific project
- */
-export async function getProjectTags(projectId: string): Promise<Tag[]> {
-  const projects = await api.projects.list();
-  const project = projects.find((p) => p.id === projectId);
-  return project?.tags || [];
-}
-
-/**
- * Adds a tag to a project
- */
-export async function addTagToProject(projectId: string, tagId: string): Promise<void> {
-  return api.tags.addToProject(projectId, tagId);
-}
-
-/**
- * Removes a tag from a project
- */
-export async function removeTagFromProject(projectId: string, tagId: string): Promise<void> {
-  return api.tags.removeFromProject(projectId, tagId);
-}
-
-// ===== Convenience Functions =====
-
-/**
- * Gets a project with its tags
- */
-export async function getProjectWithTags(projectId: string): Promise<Project> {
-  const projects = await getProjects();
-  const project = projects.find((p) => p.id === projectId);
-  if (!project) {
-    throw new Error(`Project not found: ${projectId}`);
-  }
-  return project;
-}
-
-/**
- * Gets all projects with their tags
- */
-export async function getProjectsWithTags(): Promise<Project[]> {
-  return getProjects();
-}

package/src/lib/design-doc.ts

@@ -1,74 +0,0 @@
-/**
- * Design Doc Utilities
- * Shared functions for fetching and processing design documents
- */
-
-const API_BASE = process.env.NEXT_PUBLIC_BACKEND_URL || 'http://localhost:3008';
-
-/**
- * Fetch design doc content from the backend API
- */
-export async function fetchDesignDoc(path: string, projectPath: string): Promise<string> {
-  const encodedPath = encodeURIComponent(path);
-  const encodedProjectPath = encodeURIComponent(projectPath);
-  const response = await fetch(
-    `${API_BASE}/api/fs/read?path=${encodedPath}&project_path=${encodedProjectPath}`
-  );
-  if (!response.ok) {
-    throw new Error('Failed to fetch design doc: ' + response.statusText);
-  }
-  const data = await response.json();
-  return data.content || '';
-}
-
-/**
- * Strip markdown syntax and convert to plain text preview
- * Removes headers, links, code blocks, bold, italic, etc.
- */
-export function truncateMarkdownToPlainText(markdown: string, maxChars: number = 180): string {
-  let text = markdown;
-
-  // Remove code blocks
-  text = text.replace(/```[\s\S]*?```/g, '');
-
-  // Remove inline code
-  text = text.replace(/`[^`]+`/g, '');
-
-  // Remove headers (# ## ###)
-  text = text.replace(/^#{1,6}\s+/gm, '');
-
-  // Remove links but keep text: [text](url) -> text
-  text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
-
-  // Remove bold/italic: **text** or *text* -> text
-  text = text.replace(/\*\*([^*]+)\*\*/g, '$1');
-  text = text.replace(/\*([^*]+)\*/g, '$1');
-
-  // Remove blockquotes
-  text = text.replace(/^>\s+/gm, '');
-
-  // Remove horizontal rules
-  text = text.replace(/^-{3,}$/gm, '');
-
-  // Remove list markers
-  text = text.replace(/^[\s]*[-*+]\s+/gm, '');
-  text = text.replace(/^[\s]*\d+\.\s+/gm, '');
-
-  // Collapse multiple newlines
-  text = text.replace(/\n{2,}/g, ' ');
-
-  // Trim and truncate
-  text = text.trim();
-
-  if (text.length <= maxChars) {
-    return text;
-  }
-
-  return text.slice(0, maxChars).trim() + '…';
-}
-
-/**
- * Shared prose classes for markdown rendering
- * Ensures consistent styling across preview and full view
- */
-export const designDocProseClasses = "prose prose-sm dark:prose-invert max-w-none prose-headings:scroll-mt-20 prose-pre:bg-zinc-900 prose-pre:text-zinc-100 prose-code:text-sm prose-code:bg-zinc-100 dark:prose-code:bg-zinc-800 prose-code:px-1 prose-code:py-0.5 prose-code:rounded";