@arvorco/relentless 0.1.0

package/src/prd/progress.ts

@@ -0,0 +1,198 @@
+/**
+ * Progress Tracking with Metadata
+ *
+ * Manages progress.txt with YAML frontmatter for machine-readable context
+ */
+
+import { existsSync } from "node:fs";
+import yaml from "js-yaml";
+
+/**
+ * Progress metadata stored in YAML frontmatter
+ */
+export interface ProgressMetadata {
+  /** Feature name */
+  feature: string;
+  /** When the feature was started */
+  started: string;
+  /** Last update timestamp */
+  last_updated: string;
+  /** Number of stories completed */
+  stories_completed: number;
+  /** Patterns learned during development */
+  patterns: string[];
+}
+
+/**
+ * Progress file with frontmatter and content
+ */
+export interface ProgressFile {
+  /** Parsed frontmatter metadata */
+  metadata: ProgressMetadata;
+  /** Content after frontmatter (logs and patterns) */
+  content: string;
+}
+
+/**
+ * Parse progress.txt with YAML frontmatter
+ */
+export function parseProgress(content: string): ProgressFile {
+  // Check for frontmatter delimiter
+  if (!content.startsWith("---\n")) {
+    // Legacy format without frontmatter - create default metadata
+    const lines = content.split("\n");
+    const featureLine = lines.find((l) => l.startsWith("# Progress Log:"));
+    const feature = featureLine ? featureLine.replace("# Progress Log:", "").trim() : "unknown";
+    const startedLine = lines.find((l) => l.startsWith("Started:"));
+    const started = startedLine ? startedLine.replace("Started:", "").trim() : new Date().toISOString();
+
+    return {
+      metadata: {
+        feature,
+        started,
+        last_updated: new Date().toISOString(),
+        stories_completed: 0,
+        patterns: [],
+      },
+      content,
+    };
+  }
+
+  // Find closing delimiter
+  const endIndex = content.indexOf("\n---\n", 4);
+  if (endIndex === -1) {
+    throw new Error("Progress file has opening --- but no closing --- delimiter");
+  }
+
+  // Extract frontmatter
+  const frontmatterText = content.substring(4, endIndex);
+  const metadata = yaml.load(frontmatterText) as ProgressMetadata;
+
+  // Extract content after frontmatter
+  const contentAfterFrontmatter = content.substring(endIndex + 5); // Skip "\n---\n"
+
+  return {
+    metadata,
+    content: contentAfterFrontmatter,
+  };
+}
+
+/**
+ * Serialize progress file back to string with frontmatter
+ */
+export function serializeProgress(progress: ProgressFile): string {
+  const frontmatter = yaml.dump(progress.metadata, {
+    indent: 2,
+    lineWidth: -1, // Disable line wrapping
+  });
+
+  return `---\n${frontmatter}---\n${progress.content}`;
+}
+
+/**
+ * Load progress file
+ */
+export async function loadProgress(progressPath: string): Promise<ProgressFile | null> {
+  if (!existsSync(progressPath)) {
+    return null;
+  }
+
+  const content = await Bun.file(progressPath).text();
+  return parseProgress(content);
+}
+
+/**
+ * Update progress metadata
+ */
+export async function updateProgressMetadata(
+  progressPath: string,
+  updates: Partial<ProgressMetadata>
+): Promise<void> {
+  const progress = await loadProgress(progressPath);
+  if (!progress) {
+    throw new Error(`Progress file not found: ${progressPath}`);
+  }
+
+  // Merge updates
+  progress.metadata = {
+    ...progress.metadata,
+    ...updates,
+    last_updated: new Date().toISOString(),
+  };
+
+  // Write back
+  await Bun.write(progressPath, serializeProgress(progress));
+}
+
+/**
+ * Append entry to progress log
+ */
+export async function appendProgress(progressPath: string, entry: string): Promise<void> {
+  const progress = await loadProgress(progressPath);
+  if (!progress) {
+    throw new Error(`Progress file not found: ${progressPath}`);
+  }
+
+  // Append entry
+  progress.content += `\n${entry}`;
+
+  // Update last_updated
+  progress.metadata.last_updated = new Date().toISOString();
+
+  // Write back
+  await Bun.write(progressPath, serializeProgress(progress));
+}
+
+/**
+ * Extract patterns from progress content
+ */
+export function extractPatterns(content: string): string[] {
+  const patterns: string[] = [];
+  const lines = content.split("\n");
+
+  let inLearningsSection = false;
+  for (const line of lines) {
+    // Check for "Learnings for future iterations:" header
+    if (line.includes("Learnings for future iterations:")) {
+      inLearningsSection = true;
+      continue;
+    }
+
+    // Check for section end
+    if (line.trim() === "---" || line.startsWith("##")) {
+      inLearningsSection = false;
+      continue;
+    }
+
+    // Extract patterns from learnings sections
+    if (inLearningsSection && line.trim().startsWith("-")) {
+      const pattern = line.trim().substring(1).trim(); // Remove leading "- "
+      if (pattern && pattern.startsWith("**")) {
+        // Pattern format: **Key**: Description
+        patterns.push(pattern);
+      }
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Update patterns in frontmatter from content
+ */
+export async function syncPatternsFromContent(progressPath: string): Promise<void> {
+  const progress = await loadProgress(progressPath);
+  if (!progress) {
+    return;
+  }
+
+  // Extract patterns from content
+  const patterns = extractPatterns(progress.content);
+
+  // Update metadata
+  progress.metadata.patterns = patterns;
+  progress.metadata.last_updated = new Date().toISOString();
+
+  // Write back
+  await Bun.write(progressPath, serializeProgress(progress));
+}

package/src/prd/types.ts

@@ -0,0 +1,170 @@
+/**
+ * PRD Types
+ *
+ * Defines the structure of prd.json for user stories
+ */
+
+import { z } from "zod";
+
+/**
+ * User story schema
+ */
+export const UserStorySchema = z.object({
+  id: z.string(), // e.g., "US-001"
+  title: z.string(),
+  description: z.string(),
+  acceptanceCriteria: z.array(z.string()),
+  priority: z.number().int().positive(),
+  passes: z.boolean().default(false),
+  notes: z.string().default(""),
+  dependencies: z.array(z.string()).optional(), // Array of story IDs this story depends on
+  parallel: z.boolean().optional(), // Can be executed in parallel with other stories
+  phase: z.string().optional(), // Phase marker (e.g., "Setup", "Foundation", "Stories", "Polish")
+  research: z.boolean().optional(), // Requires research phase before implementation
+});
+
+export type UserStory = z.infer<typeof UserStorySchema>;
+
+/**
+ * Complete PRD schema
+ */
+export const PRDSchema = z.object({
+  project: z.string(),
+  branchName: z.string(),
+  description: z.string(),
+  userStories: z.array(UserStorySchema),
+});
+
+export type PRD = z.infer<typeof PRDSchema>;
+
+/**
+ * Validate dependencies and detect circular dependencies
+ */
+export function validateDependencies(prd: PRD): void {
+  const storyMap = new Map<string, UserStory>();
+  for (const story of prd.userStories) {
+    storyMap.set(story.id, story);
+  }
+
+  // Check for invalid dependencies (references to non-existent stories)
+  for (const story of prd.userStories) {
+    if (story.dependencies) {
+      for (const depId of story.dependencies) {
+        if (!storyMap.has(depId)) {
+          throw new Error(`Story ${story.id} depends on non-existent story ${depId}`);
+        }
+      }
+    }
+  }
+
+  // Detect circular dependencies using DFS
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+
+  function hasCycle(storyId: string, path: string[] = []): boolean {
+    if (recursionStack.has(storyId)) {
+      const cycle = [...path, storyId].join(" -> ");
+      throw new Error(`Circular dependency detected: ${cycle}`);
+    }
+
+    if (visited.has(storyId)) {
+      return false;
+    }
+
+    visited.add(storyId);
+    recursionStack.add(storyId);
+
+    const story = storyMap.get(storyId);
+    if (story?.dependencies) {
+      for (const depId of story.dependencies) {
+        hasCycle(depId, [...path, storyId]);
+      }
+    }
+
+    recursionStack.delete(storyId);
+    return false;
+  }
+
+  for (const story of prd.userStories) {
+    hasCycle(story.id);
+  }
+}
+
+/**
+ * Check if a story's dependencies are all completed
+ */
+function areDependenciesMet(story: UserStory, prd: PRD): boolean {
+  if (!story.dependencies || story.dependencies.length === 0) {
+    return true;
+  }
+
+  const storyMap = new Map<string, UserStory>();
+  for (const s of prd.userStories) {
+    storyMap.set(s.id, s);
+  }
+
+  return story.dependencies.every((depId) => {
+    const depStory = storyMap.get(depId);
+    return depStory?.passes ?? false;
+  });
+}
+
+/**
+ * Get the next story to work on
+ */
+export function getNextStory(prd: PRD): UserStory | null {
+  // Validate dependencies first
+  validateDependencies(prd);
+
+  // Find highest priority story where passes is false and dependencies are met
+  const pendingStories = prd.userStories
+    .filter((s) => !s.passes && areDependenciesMet(s, prd))
+    .sort((a, b) => a.priority - b.priority);
+
+  return pendingStories[0] ?? null;
+}
+
+/**
+ * Check if all stories are complete
+ */
+export function isComplete(prd: PRD): boolean {
+  return prd.userStories.every((s) => s.passes);
+}
+
+/**
+ * Count stories by status
+ */
+export function countStories(prd: PRD): { total: number; completed: number; pending: number } {
+  const total = prd.userStories.length;
+  const completed = prd.userStories.filter((s) => s.passes).length;
+  const pending = total - completed;
+  return { total, completed, pending };
+}
+
+/**
+ * Infer the story type from title and description
+ */
+export function inferStoryType(story: UserStory): string {
+  const text = `${story.title} ${story.description}`.toLowerCase();
+
+  if (text.includes("database") || text.includes("migration") || text.includes("schema") || text.includes("table")) {
+    return "database";
+  }
+  if (text.includes("ui") || text.includes("component") || text.includes("browser") || text.includes("frontend") || text.includes("page")) {
+    return "ui";
+  }
+  if (text.includes("api") || text.includes("endpoint") || text.includes("server") || text.includes("route")) {
+    return "api";
+  }
+  if (text.includes("test") || text.includes("spec") || text.includes("coverage")) {
+    return "test";
+  }
+  if (text.includes("refactor") || text.includes("cleanup") || text.includes("reorganize")) {
+    return "refactor";
+  }
+  if (text.includes("doc") || text.includes("readme") || text.includes("comment")) {
+    return "docs";
+  }
+
+  return "general";
+}

package/src/tui/App.tsx

@@ -0,0 +1,85 @@
+/**
+ * Relentless TUI App
+ *
+ * Main application component that renders the full interface
+ */
+
+import React from "react";
+import { Box, Text } from "ink";
+import { Header } from "./components/Header.js";
+import { ProgressBar } from "./components/ProgressBar.js";
+import { CurrentStory } from "./components/CurrentStory.js";
+import { AgentOutput } from "./components/AgentOutput.js";
+import { StoryGrid } from "./components/StoryGrid.js";
+import { AgentStatus } from "./components/AgentStatus.js";
+import { colors } from "./theme.js";
+import type { TUIState } from "./types.js";
+
+interface AppProps {
+  state: TUIState;
+}
+
+export function App({ state }: AppProps): React.ReactElement {
+  const completedCount = state.stories.filter((s) => s.passes).length;
+  const totalCount = state.stories.length;
+
+  return (
+    <Box flexDirection="column" width="100%">
+      {/* Header */}
+      <Header agent={state.currentAgent} />
+
+      {/* Feature info and progress */}
+      <Box flexDirection="column" paddingX={1} paddingY={1}>
+        <Box>
+          <Text color={colors.dim}>Feature: </Text>
+          <Text bold>{state.feature}</Text>
+        </Box>
+        <Box marginTop={1}>
+          <Text color={colors.dim}>Progress: </Text>
+          <ProgressBar completed={completedCount} total={totalCount} />
+        </Box>
+      </Box>
+
+      {/* Current story */}
+      <Box paddingX={1}>
+        <CurrentStory
+          story={state.currentStory}
+          elapsedSeconds={state.elapsedSeconds}
+          isRunning={state.isRunning}
+        />
+      </Box>
+
+      {/* Agent output */}
+      <AgentOutput lines={state.outputLines} />
+
+      {/* Story grid */}
+      <StoryGrid
+        stories={state.stories}
+        currentStoryId={state.currentStory?.id}
+      />
+
+      {/* Agent status footer */}
+      <AgentStatus
+        agents={state.agents}
+        iteration={state.iteration}
+        maxIterations={state.maxIterations}
+      />
+
+      {/* Error display */}
+      {state.error && (
+        <Box paddingX={1}>
+          <Text color={colors.error}>Error: {state.error}</Text>
+        </Box>
+      )}
+
+      {/* Completion message */}
+      {state.isComplete && (
+        <Box paddingX={1} paddingY={1}>
+          <Text color={colors.success} bold>
+            🎉 All stories complete!
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}