ralphctl 0.1.0

package/src/store/progress.ts

@@ -0,0 +1,230 @@
+import { execSync } from 'node:child_process';
+import { assertSafeCwd, getProgressFilePath } from '@src/utils/paths.ts';
+import { appendToFile, FileNotFoundError, readTextFile } from '@src/utils/storage.ts';
+import { assertSprintStatus, getSprint, resolveSprintId } from '@src/store/sprint.ts';
+import { withFileLock } from '@src/utils/file-lock.ts';
+import { log } from '@src/theme/ui.ts';
+
+export interface LogProgressOptions {
+  sprintId?: string;
+  projectPath?: string;
+}
+
+export async function logProgress(message: string, options: LogProgressOptions = {}): Promise<void> {
+  const id = await resolveSprintId(options.sprintId);
+  const sprint = await getSprint(id);
+
+  // Check sprint status - must be active to log progress
+  assertSprintStatus(sprint, ['active'], 'log progress');
+
+  const timestamp = new Date().toISOString();
+  const projectMarker = options.projectPath ? `**Project:** ${options.projectPath}\n\n` : '';
+  const entry = `## ${timestamp}\n\n${projectMarker}${message}\n\n---\n\n`;
+  const progressPath = getProgressFilePath(id);
+  await withFileLock(progressPath, async () => {
+    await appendToFile(progressPath, entry);
+  });
+}
+
+function isExecError(err: unknown): err is Error & { status: number } {
+  return err instanceof Error && typeof (err as unknown as Record<string, unknown>)['status'] === 'number';
+}
+
+function isNodeError(err: unknown): err is Error & { code: string } {
+  return err instanceof Error && typeof (err as unknown as Record<string, unknown>)['code'] === 'string';
+}
+
+/**
+ * Get the current git commit hash and message for a path.
+ */
+function getGitCommitInfo(projectPath: string): { hash: string; message: string } | null {
+  try {
+    assertSafeCwd(projectPath);
+    // Single git command: "hash message"
+    const output = execSync('git log -1 --pretty=format:%H\\ %s', {
+      cwd: projectPath,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const spaceIndex = output.indexOf(' ');
+    return {
+      hash: output.slice(0, spaceIndex),
+      message: output.slice(spaceIndex + 1),
+    };
+  } catch (err: unknown) {
+    // Expected: not a git repo (exit code 128) — return null silently
+    if (isExecError(err) && err.status === 128) {
+      return null;
+    }
+    // Expected: git not installed (ENOENT) — return null silently
+    if (isNodeError(err) && err.code === 'ENOENT') {
+      return null;
+    }
+    // Unexpected: permission denied, corrupt repo, etc. — warn the user
+    const detail = err instanceof Error ? err.message : String(err);
+    log.warn(`Failed to get git info for ${projectPath}: ${detail}`);
+    return null;
+  }
+}
+
+export interface LogBaselinesOptions {
+  sprintId: string;
+  sprintName: string;
+  projectPaths: string[];
+}
+
+/**
+ * Log baseline git state for each project when a sprint is activated.
+ * This enables "git log baseline..HEAD" style reviews of sprint changes.
+ */
+export async function logBaselines(options: LogBaselinesOptions): Promise<void> {
+  const { sprintId, sprintName, projectPaths } = options;
+  const timestamp = new Date().toISOString();
+
+  const lines: string[] = [
+    `## ${timestamp}`,
+    '',
+    '### Sprint Baseline State',
+    '',
+    `Sprint: ${sprintName} (${sprintId})`,
+    `Activated: ${timestamp}`,
+    '',
+    '#### Project Git State at Activation',
+    '',
+  ];
+
+  // Get unique paths
+  const uniquePaths = [...new Set(projectPaths)];
+
+  for (const path of uniquePaths) {
+    const commitInfo = getGitCommitInfo(path);
+    if (commitInfo) {
+      lines.push(`- **${path}**`);
+      lines.push(`  \`${commitInfo.hash} ${commitInfo.message}\``);
+    } else {
+      lines.push(`- **${path}**`);
+      lines.push(`  *(not a git repository or unable to retrieve state)*`);
+    }
+  }
+
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  await appendToFile(getProgressFilePath(sprintId), lines.join('\n'));
+}
+
+export async function getProgress(sprintId?: string): Promise<string> {
+  const id = await resolveSprintId(sprintId);
+  try {
+    return await readTextFile(getProgressFilePath(id));
+  } catch (err) {
+    if (err instanceof FileNotFoundError) {
+      return '';
+    }
+    throw err;
+  }
+}
+
+/**
+ * Parse progress entries and filter by project path.
+ * Entries are delimited by `---` and may contain project markers in either format:
+ * - Legacy HTML comments: `<!-- project: /path -->`
+ * - Visible format: `**Project:** /path`
+ */
+/**
+ * Extract only "Learnings and Context" and "Notes for Next Tasks" sections
+ * from progress entries, capped at maxEntries most recent.
+ * Returns compressed summary suitable for task context files.
+ */
+export function summarizeProgressForContext(progress: string, projectPath: string, maxEntries = 3): string {
+  const filtered = filterProgressByProject(progress, projectPath);
+  if (!filtered.trim()) {
+    return '';
+  }
+
+  // Split into entries by --- delimiter
+  const entries = filtered.split(/\n---\n/).filter((e) => e.trim());
+
+  // Take last maxEntries entries
+  const recent = entries.slice(-maxEntries);
+
+  const summaries: string[] = [];
+
+  for (const entry of recent) {
+    // Extract entry header (first ## line with timestamp and task name)
+    const headerMatch = /^##\s+(.+)$/m.exec(entry);
+    const header = headerMatch?.[1] ?? 'Unknown entry';
+
+    // Extract "Learnings and Context" section
+    const learnings = extractSection(entry, 'Learnings and Context');
+
+    // Extract "Notes for Next Tasks" section
+    const notes = extractSection(entry, 'Notes for Next Tasks');
+
+    // Only include entries that have at least one useful section
+    if (learnings || notes) {
+      const parts: string[] = [`**${header}**`];
+      if (learnings) {
+        parts.push(`**Learnings:** ${learnings}`);
+      }
+      if (notes) {
+        parts.push(`**Notes for next tasks:** ${notes}`);
+      }
+      summaries.push(parts.join('\n'));
+    }
+  }
+
+  if (summaries.length === 0) {
+    return '';
+  }
+
+  return summaries.join('\n\n');
+}
+
+/**
+ * Extract content of a markdown section (### heading) from a progress entry.
+ * Returns the section content trimmed, or null if section not found.
+ */
+function extractSection(entry: string, sectionName: string): string | null {
+  // Match ### Section Name followed by content until next ### or end of string
+  // No 'm' flag — $ must match end of string, not end of line
+  const regex = new RegExp(`###\\s+${sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\n([\\s\\S]*?)(?=###|$)`);
+  const match = regex.exec(entry);
+  if (!match?.[1]) return null;
+
+  const content = match[1].trim();
+  return content || null;
+}
+
+export function filterProgressByProject(progress: string, projectPath: string): string {
+  if (!progress.trim()) {
+    return '';
+  }
+
+  // Split by entry delimiter
+  const entries = progress.split(/\n---\n/).filter((e) => e.trim());
+
+  const filtered = entries.filter((entry) => {
+    // Try visible format first: **Project:** /some/path
+    const visibleMatch = /\*\*Project:\*\*\s*(.+?)(?:\n|$)/.exec(entry);
+    if (visibleMatch?.[1]) {
+      return visibleMatch[1].trim() === projectPath;
+    }
+
+    // Fall back to legacy HTML comment format: <!-- project: /some/path -->
+    const htmlMatch = /<!--\s*project:\s*(.+?)\s*-->/.exec(entry);
+    if (htmlMatch?.[1]) {
+      return htmlMatch[1] === projectPath;
+    }
+
+    // No marker = include (baseline entries, general notes)
+    return true;
+  });
+
+  if (filtered.length === 0) {
+    return '';
+  }
+
+  return filtered.join('\n---\n') + '\n\n---\n\n';
+}

package/src/store/project.ts

@@ -0,0 +1,276 @@
+import { basename, resolve } from 'node:path';
+import { getProjectsFilePath, validateProjectPath } from '../utils/paths.js';
+import { fileExists, readValidatedJson, writeValidatedJson } from '../utils/storage.js';
+import { type Project, type Projects, ProjectsSchema, type Repository } from '../schemas/index.js';
+
+export class ProjectNotFoundError extends Error {
+  public readonly projectName: string;
+
+  constructor(projectName: string) {
+    super(`Project not found: ${projectName}`);
+    this.name = 'ProjectNotFoundError';
+    this.projectName = projectName;
+  }
+}
+
+export class ProjectExistsError extends Error {
+  public readonly projectName: string;
+
+  constructor(projectName: string) {
+    super(`Project already exists: ${projectName}`);
+    this.name = 'ProjectExistsError';
+    this.projectName = projectName;
+  }
+}
+
+/**
+ * Migration: Convert old paths[] format to repositories[] format.
+ * Non-production tool - minimal migration support.
+ */
+interface LegacyProject {
+  name: string;
+  displayName: string;
+  paths?: string[];
+  repositories?: Repository[];
+  description?: string;
+}
+
+function migrateProjectIfNeeded(project: LegacyProject): Project {
+  // Already in new format
+  if (project.repositories) {
+    return project as Project;
+  }
+
+  // Old paths[] format - convert to repositories[]
+  if (project.paths) {
+    return {
+      name: project.name,
+      displayName: project.displayName,
+      repositories: project.paths.map((p) => ({
+        name: basename(p),
+        path: p,
+      })),
+      description: project.description,
+    };
+  }
+
+  throw new Error(`Invalid project data: no paths or repositories for ${project.name}`);
+}
+
+/**
+ * Get all projects.
+ * Handles migration from old paths[] format to repositories[] format.
+ */
+export async function listProjects(): Promise<Projects> {
+  const filePath = getProjectsFilePath();
+  if (!(await fileExists(filePath))) {
+    return [];
+  }
+
+  // Read raw data to check for migration needs
+  const { readFile } = await import('node:fs/promises');
+  const content = await readFile(filePath, 'utf-8');
+  const rawData = JSON.parse(content) as LegacyProject[];
+
+  // Check if any projects need migration (old paths[] format)
+  const needsMigration = rawData.some((p) => p.paths && !p.repositories);
+
+  if (needsMigration) {
+    const migrated = rawData.map(migrateProjectIfNeeded);
+    const validated = ProjectsSchema.parse(migrated);
+    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    return validated;
+  }
+
+  return readValidatedJson(filePath, ProjectsSchema);
+}
+
+/**
+ * Get a project by name.
+ * @throws ProjectNotFoundError if project doesn't exist
+ */
+export async function getProject(name: string): Promise<Project> {
+  const projects = await listProjects();
+  const project = projects.find((p) => p.name === name);
+  if (!project) {
+    throw new ProjectNotFoundError(name);
+  }
+  return project;
+}
+
+/**
+ * Check if a project exists.
+ */
+export async function projectExists(name: string): Promise<boolean> {
+  const projects = await listProjects();
+  return projects.some((p) => p.name === name);
+}
+
+/**
+ * Create a new project.
+ * @throws ProjectExistsError if project already exists
+ */
+export async function createProject(project: Project): Promise<Project> {
+  const projects = await listProjects();
+
+  if (projects.some((p) => p.name === project.name)) {
+    throw new ProjectExistsError(project.name);
+  }
+
+  // Validate that all repository paths exist
+  const pathErrors: string[] = [];
+  for (const repo of project.repositories) {
+    const resolved = resolve(repo.path);
+    const validation = await validateProjectPath(resolved);
+    if (validation !== true) {
+      pathErrors.push(`  ${repo.path}: ${validation}`);
+    }
+  }
+  if (pathErrors.length > 0) {
+    throw new Error(`Invalid project paths:\n${pathErrors.join('\n')}`);
+  }
+
+  // Resolve all paths to absolute and derive names, preserving scripts
+  const normalizedProject: Project = {
+    ...project,
+    repositories: project.repositories.map((repo) => ({
+      ...repo,
+      name: repo.name || basename(repo.path),
+      path: resolve(repo.path),
+    })),
+  };
+
+  projects.push(normalizedProject);
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+
+  return normalizedProject;
+}
+
+/**
+ * Update an existing project.
+ * @throws ProjectNotFoundError if project doesn't exist
+ */
+export async function updateProject(name: string, updates: Partial<Omit<Project, 'name'>>): Promise<Project> {
+  const projects = await listProjects();
+  const index = projects.findIndex((p) => p.name === name);
+
+  if (index === -1) {
+    throw new ProjectNotFoundError(name);
+  }
+
+  // Validate new repositories if provided
+  if (updates.repositories) {
+    const pathErrors: string[] = [];
+    for (const repo of updates.repositories) {
+      const resolved = resolve(repo.path);
+      const validation = await validateProjectPath(resolved);
+      if (validation !== true) {
+        pathErrors.push(`  ${repo.path}: ${validation}`);
+      }
+    }
+    if (pathErrors.length > 0) {
+      throw new Error(`Invalid project paths:\n${pathErrors.join('\n')}`);
+    }
+    // Resolve paths to absolute and ensure names, preserving scripts
+    updates.repositories = updates.repositories.map((repo) => ({
+      ...repo,
+      name: repo.name || basename(repo.path),
+      path: resolve(repo.path),
+    }));
+  }
+
+  const existingProject = projects[index];
+  if (!existingProject) {
+    throw new ProjectNotFoundError(name);
+  }
+
+  const updatedProject: Project = {
+    name: existingProject.name,
+    displayName: updates.displayName ?? existingProject.displayName,
+    repositories: updates.repositories ?? existingProject.repositories,
+    description: updates.description ?? existingProject.description,
+  };
+
+  projects[index] = updatedProject;
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+
+  return updatedProject;
+}
+
+/**
+ * Remove a project.
+ * @throws ProjectNotFoundError if project doesn't exist
+ */
+export async function removeProject(name: string): Promise<void> {
+  const projects = await listProjects();
+  const index = projects.findIndex((p) => p.name === name);
+
+  if (index === -1) {
+    throw new ProjectNotFoundError(name);
+  }
+
+  projects.splice(index, 1);
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+}
+
+/**
+ * Get all repositories for a project.
+ * @throws ProjectNotFoundError if project doesn't exist
+ */
+export async function getProjectRepos(name: string): Promise<Repository[]> {
+  const project = await getProject(name);
+  return project.repositories;
+}
+
+/**
+ * Add a repository to an existing project.
+ * Accepts a full Repository object to preserve scripts set during interactive prompting.
+ * @throws ProjectNotFoundError if project doesn't exist
+ */
+export async function addProjectRepo(name: string, repo: Repository): Promise<Project> {
+  const project = await getProject(name);
+  const resolvedPath = resolve(repo.path);
+
+  // Validate the path
+  const validation = await validateProjectPath(resolvedPath);
+  if (validation !== true) {
+    throw new Error(`Invalid path ${repo.path}: ${validation}`);
+  }
+
+  // Check if path already exists
+  if (project.repositories.some((r) => r.path === resolvedPath)) {
+    return project; // Already exists, no-op
+  }
+
+  const normalizedRepo: Repository = {
+    ...repo,
+    name: repo.name || basename(resolvedPath),
+    path: resolvedPath,
+  };
+
+  return updateProject(name, {
+    repositories: [...project.repositories, normalizedRepo],
+  });
+}
+
+/**
+ * Remove a repository from an existing project.
+ * @throws ProjectNotFoundError if project doesn't exist
+ * @throws Error if trying to remove the last repository
+ */
+export async function removeProjectRepo(name: string, path: string): Promise<Project> {
+  const project = await getProject(name);
+  const resolvedPath = resolve(path);
+
+  const newRepos = project.repositories.filter((r) => r.path !== resolvedPath);
+
+  if (newRepos.length === 0) {
+    throw new Error('Cannot remove the last repository from a project');
+  }
+
+  if (newRepos.length === project.repositories.length) {
+    return project; // Path wasn't in the list, no-op
+  }
+
+  return updateProject(name, { repositories: newRepos });
+}