factory-factory 0.1.0

package/prisma/schema.prisma

@@ -0,0 +1,195 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client"
+  output   = "./generated"
+}
+
+datasource db {
+  provider = "sqlite"
+}
+
+// Enums
+
+enum WorkspaceStatus {
+  NEW          // Workspace created, nothing started
+  PROVISIONING // Git worktree being created, startup script running
+  READY        // Successfully initialized
+  FAILED       // Initialization failed
+  ARCHIVED     // Workspace archived
+}
+
+enum SessionStatus {
+  IDLE
+  RUNNING
+  PAUSED
+  COMPLETED
+  FAILED
+}
+
+enum PRState {
+  NONE
+  DRAFT
+  OPEN
+  CHANGES_REQUESTED
+  APPROVED
+  MERGED
+  CLOSED
+}
+
+enum CIStatus {
+  UNKNOWN   // No CI configured or not yet fetched
+  PENDING   // CI is running
+  SUCCESS   // All checks passed
+  FAILURE   // One or more checks failed
+}
+
+enum KanbanColumn {
+  BACKLOG
+  IN_PROGRESS
+  WAITING
+  PR_OPEN
+  APPROVED
+  MERGED
+  DONE
+}
+
+
+// Models
+model Project {
+  id                String      @id @default(cuid())
+  name              String
+  slug              String      @unique
+  repoPath          String
+  worktreeBasePath  String
+  defaultBranch     String      @default("main")
+  githubOwner       String?
+  githubRepo        String?
+  isArchived        Boolean     @default(false)
+
+  // Startup script configuration
+  startupScriptCommand  String?   // Inline shell command
+  startupScriptPath     String?             // Path to script in repo
+  startupScriptTimeout  Int       @default(300)  // Timeout in seconds
+
+  createdAt         DateTime    @default(now())
+  updatedAt         DateTime    @updatedAt
+
+  // Relations
+  workspaces        Workspace[]
+
+  @@index([slug])
+  @@index([isArchived])
+}
+
+model DecisionLog {
+  id                String      @id @default(cuid())
+  agentId           String      // Can be sessionId or any identifier
+  decision          String
+  reasoning         String
+  context           String?
+  timestamp         DateTime    @default(now())
+
+  @@index([agentId, timestamp])
+  @@index([timestamp])
+}
+
+model Workspace {
+  id                  String            @id @default(cuid())
+  projectId           String
+  project             Project           @relation(fields: [projectId], references: [id])
+  name                String
+  description         String?
+  status              WorkspaceStatus   @default(NEW)
+  worktreePath        String?
+  branchName          String?
+
+  // Initialization tracking (used by NEW, PROVISIONING, FAILED states)
+  initErrorMessage    String?
+  initStartedAt       DateTime?
+  initCompletedAt     DateTime?
+  initRetryCount      Int                 @default(0)
+
+  // Run script tracking (from factory-factory.json)
+  runScriptCommand        String?           // The run script command to execute
+  runScriptCleanupCommand String?           // The cleanup script command to execute on stop
+  runScriptPid            Int?              // Process ID of running script
+  runScriptPort           Int?              // Allocated port for the running script
+  runScriptStartedAt      DateTime?         // When the run script was started
+  runScriptStatus         SessionStatus     @default(IDLE)  // IDLE, RUNNING, FAILED, etc.
+
+  prUrl               String?
+  githubIssueNumber   Int?
+  githubIssueUrl      String?
+  claudeSessions      ClaudeSession[]
+  terminalSessions    TerminalSession[]
+  createdAt           DateTime          @default(now())
+  updatedAt           DateTime          @updatedAt
+
+  // PR tracking (cached from GitHub)
+  prNumber            Int?
+  prState             PRState           @default(NONE)
+  prReviewState       String?           // Raw GitHub review state
+  prCiStatus          CIStatus          @default(UNKNOWN)  // CI check status
+  prUpdatedAt         DateTime?         // Last PR sync time
+
+  // Activity tracking
+  hasHadSessions      Boolean           @default(false)
+
+  // Cached kanban column (for list performance)
+  cachedKanbanColumn  KanbanColumn      @default(BACKLOG)
+  stateComputedAt     DateTime?         // Last kanban column computation
+
+  @@index([projectId])
+  @@index([status])
+  @@index([cachedKanbanColumn])
+  // Composite indexes for common query patterns
+  @@index([projectId, status])
+  @@index([projectId, cachedKanbanColumn])
+}
+
+model ClaudeSession {
+  id               String        @id @default(cuid())
+  workspaceId      String
+  workspace        Workspace     @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+  name             String?
+  workflow         String        // "explore", "implement", "test"
+  model            String        @default("sonnet")
+  status           SessionStatus @default(IDLE)
+  claudeSessionId  String?       // For resume
+  claudeProcessPid Int?
+  createdAt        DateTime      @default(now())
+  updatedAt        DateTime      @updatedAt
+
+  @@index([workspaceId])
+  @@index([status])
+}
+
+model TerminalSession {
+  id              String        @id @default(cuid())
+  workspaceId     String
+  workspace       Workspace     @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+  name            String?
+  status          SessionStatus @default(IDLE)
+  pid             Int?
+  createdAt       DateTime      @default(now())
+  updatedAt       DateTime      @updatedAt
+
+  @@index([workspaceId])
+  @@index([status])
+}
+
+model UserSettings {
+  id                String   @id @default(cuid())
+  userId            String   @default("default") @unique  // Single user for now, expandable later
+
+  // IDE Settings
+  preferredIde      String   @default("cursor")  // "cursor" | "vscode" | "custom"
+  customIdeCommand  String?  // For custom IDE, supports placeholders like {workspace}
+
+  createdAt         DateTime @default(now())
+  updatedAt         DateTime @updatedAt
+
+  @@index([userId])
+}

package/prompts/quick-actions/fetch-rebase.md

@@ -0,0 +1,15 @@
+---
+name: Fetch & Rebase
+description: Fetch latest from origin and rebase onto main
+type: agent
+icon: git-branch
+---
+Please fetch the latest changes from origin and rebase the current branch onto origin/main. Follow these steps:
+
+1. Check for uncommitted changes with `git status`
+2. If there are uncommitted changes, stash them with `git stash`
+3. Fetch the latest changes with `git fetch origin`
+4. Rebase onto origin/main with `git rebase origin/main`
+5. If the stash was created, pop it back with `git stash pop`
+
+If there are any conflicts during the rebase, help me resolve them. Provide clear feedback about what happened during each step.

package/prompts/quick-actions/rename-branch.md

@@ -0,0 +1,15 @@
+---
+name: Rename Branch
+description: Rename the branch based on conversation context
+type: agent
+icon: git-branch
+---
+Please rename the current branch to something descriptive based on our conversation so far.
+
+Use `git branch -m <new-name>` to rename the branch. Choose a branch name that:
+- Uses concrete, specific language
+- Avoids abstract nouns
+- Is concise (under 30 characters)
+- Reflects the work being done in this workspace
+
+Consider our conversation history and any code changes when choosing the name.

package/prompts/quick-actions/review.md

@@ -0,0 +1,11 @@
+---
+name: Review
+description: Review the current changes
+type: agent
+icon: eye
+---
+Please review the recent changes in this workspace. Run `git diff` to see the changes, then provide a thorough code review focusing on:
+1. Code quality and best practices
+2. Potential bugs or edge cases
+3. Performance considerations
+4. Suggestions for improvement

package/prompts/quick-actions/simplify.md

@@ -0,0 +1,7 @@
+---
+name: Simplify
+description: Simplify and refine recent code changes
+type: agent
+icon: sparkles
+---
+Run /code-simplifier to simplify and refine the recently modified code.

package/prompts/workflows/bugfix.md

@@ -0,0 +1,57 @@
+---
+name: Bug Fix
+description: Investigate and fix bugs with regression tests
+expectsPR: true
+---
+
+# Bug Fix Workflow
+
+You are fixing a bug. Follow this workflow to ensure the fix is correct and doesn't introduce regressions.
+
+## Workflow Steps
+
+### 1. Reproduce the Bug
+- Understand the reported symptoms
+- Reproduce the issue locally if possible
+- Document the reproduction steps
+
+### 2. Investigate Root Cause
+- Use search tools to find relevant code
+- Trace the code path that leads to the bug
+- Identify the root cause, not just symptoms
+
+### 3. Write a Failing Test
+- Create a test that reproduces the bug
+- Verify the test fails before the fix
+- This ensures the bug is actually fixed
+
+### 4. Implement the Fix
+- Make the minimal change needed to fix the bug
+- Avoid refactoring or feature additions
+- Keep the fix focused and reviewable
+
+### 5. Verify the Fix
+- Confirm your test now passes
+- Run the full test suite to check for regressions
+- Test related functionality manually if needed
+
+### 6. Verify Build and Lint
+- Run `pnpm typecheck` to catch type errors
+- Run `pnpm check:fix` to fix linting issues
+- Ensure the build passes
+
+### 7. Create Pull Request
+- Commit with a descriptive message referencing the bug
+- Push your branch: `git push -u origin HEAD`
+- Create the PR using the GitHub CLI:
+  ```bash
+  gh pr create --title "Fix: Brief description" --body "Description with reproduction steps and fix explanation"
+  ```
+- Include reproduction steps and fix explanation in the PR body
+
+## Guidelines
+
+- **Understand before fixing**: Avoid shotgun debugging
+- **Minimal changes**: Fix only what's broken
+- **Regression tests**: Every bug fix should include a test
+- **Document the root cause**: Help future developers understand

package/prompts/workflows/explore.md

@@ -0,0 +1,54 @@
+---
+name: Explore
+description: Understand codebase structure and answer questions
+expectsPR: false
+---
+
+# Exploration Workflow
+
+You are exploring the codebase to understand how things work or answer questions.
+
+## When to Use This Workflow
+
+- Learning how a feature is implemented
+- Understanding code architecture
+- Researching before implementing a feature
+- Answering questions about the codebase
+- Finding relevant code for a task
+
+## Exploration Techniques
+
+### 1. Start with Entry Points
+- Find main files, routers, or handlers
+- Trace the code path from user action to implementation
+- Identify key modules and their responsibilities
+
+### 2. Use Search Effectively
+- `Grep` for specific function or variable names
+- `Glob` for file patterns (e.g., `**/*.test.ts`)
+- Read file headers and exports first
+
+### 3. Build Mental Models
+- Map out module dependencies
+- Identify core abstractions and patterns
+- Note important files and their purposes
+
+### 4. Document Findings
+- Summarize what you learned
+- Note important files and code locations
+- Explain patterns and conventions used
+
+## Guidelines
+
+- **Use Task tool for deep dives**: Spawn exploration agents to protect context
+- **Be systematic**: Start broad, then narrow down
+- **Read before searching**: Sometimes reading related code is faster
+- **Share knowledge**: Document findings clearly for future reference
+
+## Output Format
+
+When answering questions, include:
+- Direct answer to the question
+- Relevant file paths with line numbers
+- Brief explanation of how the code works
+- Any caveats or edge cases to be aware of

package/prompts/workflows/feature.md

@@ -0,0 +1,54 @@
+---
+name: Feature
+description: End-to-end feature implementation with PR creation
+expectsPR: true
+---
+
+# Feature Implementation Workflow
+
+You are implementing a new feature. Follow this workflow to deliver high-quality, production-ready code.
+
+## Workflow Steps
+
+### 1. Understand Requirements
+- Read any linked issues, PRs, or documentation
+- Clarify ambiguous requirements before starting implementation
+- Identify affected areas of the codebase
+
+### 2. Plan the Implementation
+- Use the TodoWrite tool to create a task list
+- Break down the work into logical commits
+- Consider edge cases and error handling upfront
+
+### 3. Implement the Feature
+- Write clean, well-structured code
+- Follow existing patterns in the codebase
+- Add appropriate type definitions
+- Keep commits focused and atomic
+
+### 4. Test Your Changes
+- Run the existing test suite (`pnpm test`)
+- Add new tests for your feature
+- Test edge cases and error scenarios
+- Verify the feature works end-to-end
+
+### 5. Verify Build and Lint
+- Run `pnpm typecheck` to catch type errors
+- Run `pnpm check:fix` to fix linting issues
+- Ensure the build passes (`pnpm build:all`)
+
+### 6. Create Pull Request
+- Commit all changes with descriptive messages
+- Push your branch: `git push -u origin HEAD`
+- Create the PR using the GitHub CLI:
+  ```bash
+  gh pr create --title "Your PR title" --body "Description of changes"
+  ```
+- Include a clear summary, what changed, and how to test it in the PR body
+
+## Guidelines
+
+- **Protect context**: For complex sub-tasks, use the Task tool to spawn specialized agents
+- **Commit early, commit often**: Make atomic commits as you complete each logical unit
+- **Test-driven when appropriate**: Write tests before or alongside implementation
+- **Ask questions**: If requirements are unclear, ask before making assumptions

package/prompts/workflows/followup.md

@@ -0,0 +1,32 @@
+---
+name: Follow-up
+description: Continue previous work or handle ad-hoc tasks
+expectsPR: false
+---
+
+# Follow-up Session
+
+This is a follow-up session. Continue where the previous session left off.
+
+## Context Recovery
+
+If you're resuming previous work:
+1. Review the conversation history
+2. Check git status for uncommitted changes
+3. Look at the TodoWrite list for pending tasks
+4. Identify what was completed and what remains
+
+## Ad-hoc Tasks
+
+For new tasks in this session:
+1. Understand the request
+2. Create a plan if needed (use TodoWrite)
+3. Execute the task
+4. Verify the result
+
+## Guidelines
+
+- **Resume gracefully**: Don't repeat work that's already done
+- **Check state**: Review git status, test results, and build state
+- **Ask for clarification**: If the previous context is unclear, ask
+- **Commit frequently**: Don't let work pile up uncommitted

package/scripts/postinstall.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for factory-factory
+ *
+ * Handles:
+ * 1. Prisma client generation (with explicit schema path for npm installs)
+ * 2. node-pty spawn-helper permissions
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, chmodSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirname, '..');
+
+// Generate Prisma client if schema exists
+const schemaPath = join(projectRoot, 'prisma', 'schema.prisma');
+if (existsSync(schemaPath)) {
+	try {
+		console.log('Generating Prisma client...');
+		execSync(`npx prisma generate --schema="${schemaPath}"`, {
+			stdio: 'inherit',
+			cwd: projectRoot,
+		});
+	} catch (error) {
+		console.error('Failed to generate Prisma client:', error.message);
+		console.error(
+			'You may need to run "npx prisma generate" manually after installation.',
+		);
+		// Don't fail the install - the CLI will show a better error at runtime
+	}
+}
+
+// Fix node-pty spawn-helper permissions (Unix only)
+if (process.platform !== 'win32') {
+	try {
+		const prebuildsDir = join(
+			projectRoot,
+			'node_modules',
+			'node-pty',
+			'prebuilds',
+		);
+
+		if (existsSync(prebuildsDir)) {
+			// Find all spawn-helper files in prebuild directories
+			for (const platform of readdirSync(prebuildsDir)) {
+				const spawnHelper = join(prebuildsDir, platform, 'spawn-helper');
+				if (existsSync(spawnHelper)) {
+					try {
+						chmodSync(spawnHelper, 0o755);
+					} catch {
+						// Ignore permission errors
+					}
+				}
+			}
+		}
+	} catch {
+		// Ignore if node-pty doesn't exist
+	}
+}