@profoundlogic/coderflow-server 0.2.1

package/dist/web-ui/public/docs/code/cli.md

@@ -0,0 +1,102 @@
+# CLI
+
+The CLI applies completed task patches to your local repositories. It bridges server-based AI work with your local development.
+
+## Installation
+
+```bash
+npm install -g @profoundlogic/coderflow-cli
+```
+
+## Connecting to the Server
+
+```bash
+coder login
+```
+
+Enter your server URL and credentials when prompted.
+
+## Applying Patches
+
+Apply changes from a completed task to your local repos:
+
+```bash
+# Interactive selection from completed tasks
+coder apply
+
+# Apply a specific task
+coder apply <task-id>
+
+# Apply only certain files
+coder apply --include="*.js"
+```
+
+Changes are staged (`git add`) but not committed, so you can review before committing.
+
+## Discarding Changes
+
+Undo applied changes (unstage, restore, clean):
+
+```bash
+# Discard in default environment
+coder discard
+
+# Discard in specific environment
+coder discard --env=myproject
+
+# Skip confirmation
+coder discard --yes
+```
+
+## Attaching to Containers
+
+```bash
+# Connect to last container
+coder attach
+
+# Connect with bash shell
+coder attach --shell
+
+# Connect to specific container
+coder attach <container-id>
+```
+
+## Configuration and Profiles
+
+Manage connection settings:
+
+```bash
+# Show current config
+coder config show
+
+# Set server URL
+coder config set serverUrl http://myserver:3000
+```
+
+Use profiles to connect to different servers:
+
+```bash
+# Create profile
+coder profile create production
+
+# Switch profiles
+coder profile switch production
+
+# Use profile for one command
+coder --profile=production apply
+```
+
+## Getting Help
+
+```bash
+# General help
+coder --help
+
+# All commands
+coder --help-all
+
+# Help for specific command
+coder apply --help
+```
+
+Task management commands are available for when you prefer CLI over the Web UI. Run `coder --help-all` to see `run`, `status`, `results`, `list`, and more.

package/dist/web-ui/public/docs/code/files-and-editing.md

@@ -0,0 +1,86 @@
+# Files & Editing
+
+CoderFlow lets you edit files directly in the running container and view how they've changed. You can browse the diff, edit files interactively, and discard changes if needed.
+
+## Viewing Changed Files
+
+The **Changed Files** section displays all repository changes made during the task execution. When a task completes or when you view an active task, you'll see:
+
+- **Change statistics** - Count of repositories, files changed, lines added, and lines deleted
+- **Repository list** - Each modified repository with the number of files changed
+- **File diffs** - Detailed unified diffs showing what changed in each file, with syntax highlighting
+
+You can toggle each file's diff to expand or collapse it. The diffs are read-only and show the state of the repository at the moment the task finished syncing.
+
+## Editing Files
+
+You can edit files directly in the container using the built-in Monaco code editor:
+
+1. Click the **Edit** button next to any file in the Changed Files section
+2. The editor opens with the current file content from the container
+3. Make your edits in the editor
+4. Click **Save & Sync** to:
+   - Write your changes to the file in the container
+   - Sync the repository to update the diff view
+   - Refresh the Changed Files display with your new changes
+
+The editor supports:
+- Syntax highlighting for hundreds of languages (automatically detected from file extension)
+- Line numbers and code folding
+- Search and replace (Ctrl+H / Cmd+H)
+- Auto-formatting support
+- Minimap navigation for larger files
+
+**Note:** Editing is only available while the container is running. If the container stops, you'll need to restart the container to enable editing.
+
+## VS Code IDE
+
+For more extensive editing, open the container in a full web-based VS Code environment. This gives you a complete IDE experience directly in your browser—no local installation required.
+
+### Opening VS Code
+
+Click the **VS Code** button in the task detail view. The IDE opens in a new browser tab connected to the running container.
+
+Use the dropdown arrow next to the button to choose which folder to open:
+
+- **Workspace**: Opens `/workspace`, where repositories are cloned
+- **Container Root**: Opens the entire container filesystem
+- **Task Output**: Opens `/task-output`, where agent results are stored
+- **Repository folders**: Opens specific repository directories (your environment may contain multiple repos)
+
+### Features
+
+The web-based VS Code includes:
+
+- Full syntax highlighting and IntelliSense for all major languages
+- Integrated terminal with direct container access
+- Git integration for viewing changes and staging files
+- Search across files and folders
+- Extensions for common development tasks
+- Auto-save (changes save automatically after 1 second)
+
+The theme automatically matches your CoderFlow theme preference (dark or light).
+
+### When to Use VS Code vs. Quick Edit
+
+- **Quick Edit (Monaco)**: Best for small, targeted changes to individual files you've already identified
+- **VS Code**: Best for exploring the codebase, making changes across multiple files, running commands, or when you need full IDE capabilities
+
+Both edit the same container filesystem—changes made in VS Code appear in the Changed Files view after syncing.
+
+If you prefer working in your local VS Code installation, see **VS Code Extension** for how to connect directly to CoderFlow tasks.
+
+## Discarding Changes
+
+To revert changes to a file back to what's in the Git repository:
+
+1. Click the **Discard** button next to the file in the Changed Files section
+2. A confirmation modal appears with the filename
+3. Click **Discard** to confirm
+
+The discard operation:
+- Uses `git checkout` if the file exists in the repository's HEAD commit
+- Removes the file entirely if it's a new file that doesn't exist in HEAD (handles staged and untracked files)
+- Updates the Changed Files view to reflect the removal of that file's changes
+
+After discarding, you can immediately see the updated diffs. If you discard all changes to a file, it disappears from the Changed Files section.

package/dist/web-ui/public/docs/code/terminal-access.md

@@ -0,0 +1,110 @@
+# Terminal Access
+
+You can open an interactive terminal connected directly to the task's container. This lets you run commands, explore the filesystem, resume agents, and debug issues in real-time.
+
+## Web-Based Terminal
+
+Click the **Terminal** button in the task toolbar to open a terminal in a new browser tab. You're immediately connected to the running container and can execute commands.
+
+The web-based terminal supports:
+- Full shell capabilities (bash)
+- Running commands and tools installed in the container
+- Interactive prompts and text input
+- Colors and text formatting
+- Standard input/output redirection
+
+This is the quickest way to access the container—no local setup required.
+
+## Attaching from Your Own Terminal
+
+If you prefer using your local terminal application, click the dropdown arrow next to the Terminal button and select **Copy Attach Command**. This copies a `coder` CLI command to your clipboard.
+
+Paste and run this command in your local terminal to attach directly to the container. This gives you:
+- Your preferred terminal emulator and configuration
+- Better keyboard shortcut support
+- Integration with local tools and shell customizations
+- Easier copy/paste workflows
+
+The attach command connects to the same container as the web terminal—both access the identical environment.
+
+**Note:** Terminal access is only available while the container is running. If the container stops, restart it to use the terminal again.
+
+## Working in the Container
+
+The container environment has a specific structure:
+
+- **`/workspace`** - The main working directory where repositories are cloned. This is where you'll spend most of your time. All repository code, configurations, and edits live here.
+- **`/task-output`** - Output directory containing task metadata, logs, and state information. This is managed by the system.
+
+When you open a terminal, it starts in the `/workspace` directory by default. All code changes you make here (whether through file editing or terminal commands) are reflected in the Changed Files section after syncing.
+
+### Environment Setup
+
+The container includes:
+- Pre-installed AI agent runtimes (Claude Code, Codex, Gemini, etc.)
+- Git configured for the workspace
+- Development tools (Node.js, Python, etc.)
+- SSH and other utilities for advanced workflows
+
+## Common Operations
+
+### Run a Shell Command
+
+```bash
+# Any bash command works as normal
+ls -la
+grep -r "search-term" .
+npm install
+python script.py
+```
+
+### Resume an AI Agent
+
+The terminal dropdown menu provides quick shortcuts to resume agents:
+
+```bash
+# Resume Claude Code from the last session
+claude resume
+
+# Resume Codex from the last session
+codex resume
+
+# Start a new Claude Code session
+claude exec
+```
+
+These commands automatically set up the necessary environment and load previous session state if available.
+
+### Apply a Patch Locally
+
+If you want to apply the current task's patch to a local repository on your machine, use the CLI (not in the terminal):
+
+```bash
+# From your local machine
+coder apply <task-id> <filename>
+```
+
+This is useful if you prefer to review and integrate changes in your local development environment.
+
+### Explore the Workspace
+
+```bash
+# See what repositories are available
+ls /workspace
+
+# View repository status
+cd /workspace/<repo-name>
+git status
+
+# See recent commits
+git log --oneline -10
+```
+
+### Interact with the Agent
+
+When an agent is running, you can:
+- Inspect what it's doing with logs
+- Check intermediate results in `/task-output`
+- Modify files and re-run commands to guide the agent
+
+All changes made in the terminal contribute to the final diff and appear in the Changed Files section.

package/dist/web-ui/public/docs/code/vscode-extension.md

@@ -0,0 +1,58 @@
+# VS Code Extension
+
+The CoderFlow extension lets you preview and apply AI-generated changes directly in VS Code.
+
+- Browse completed tasks with code changes
+- Preview diffs side-by-side
+- Apply changes to your local repositories
+- Work with multi-repository projects
+
+**Note**: Create and manage tasks in the Web UI. The extension is for reviewing and applying completed work.
+
+## Installation
+
+**From VS Code Marketplace:**
+Search for "CoderFlow" in Extensions and click Install.
+
+**From VSIX File:**
+1. Get the `.vsix` file from your admin
+2. In VS Code: Extensions → `...` menu → Install from VSIX
+
+## Connecting to the Server
+
+1. Click the CoderFlow icon in the Activity Bar
+2. Click the server icon to open Profile Manager
+3. Create a profile with your server URL and credentials
+4. Tasks from completed work will appear in the tree view
+
+## Previewing Changes
+
+Click the diff icon next to any file to see changes side-by-side.
+
+## Applying Changes
+
+**Apply all changes from a variant:**
+Click the ↓ icon next to the AI agent name (Claude, Codex, etc.)
+
+**Apply a single file:**
+Click the ↓ icon next to an individual file.
+
+**When You Have Uncommitted Work:**
+If your repository has uncommitted changes, you'll be prompted to:
+- **Stash & Continue** - Saves your work, applies patch (recommended)
+- **Discard & Continue** - Loses your work, applies patch
+- **View Changes** - Opens Source Control to review first
+
+## Multi-Repository Projects
+
+Open all repositories in your VS Code workspace. The extension matches folders by name and applies changes to each repository.
+
+## Troubleshooting
+
+**"Cannot find repository"**
+- Ensure the repository folder is open in your workspace
+- Folder name must match the repository name on the server
+
+**Connection issues**
+- Verify server URL in Profile Manager
+- Re-login if your API key expired

package/dist/web-ui/public/docs/getting-started/core-concepts.md

@@ -0,0 +1,129 @@
+# Core Concepts
+
+## Environments
+
+An **environment** represents a complete development workspace packaged as a Docker image. It contains your source code repositories, build tools, runtime dependencies, and any application servers needed to run and test your software.
+
+Administrators configure environments to match your team's development setup. When you create a task, you select which environment to use, and CoderFlow launches an isolated container from that image. This ensures every agent works in a consistent, reproducible environment with access to the correct codebase and tools.
+
+Environments can be scheduled to rebuild automatically, keeping dependencies current and repositories synced with your latest code.
+
+## Skills
+
+**Skills** are reusable, prompt-based actions that agents can invoke while working. Skills can include their own instructions and supporting files, and they are managed by administrators in the Skills area of the Web UI.
+
+Skills are assigned at the environment level. When a task launches, CoderFlow injects the assigned skills into the task container so the agent can use them immediately.
+
+## The Parallel Agent Workflow
+
+CoderFlow's most powerful capability is running multiple AI agents in parallel on the same task. This approach dramatically improves code quality by leveraging the diverse problem-solving approaches of different agents.
+
+### 1. Submit a Task to Multiple Agents
+
+When you have a complex task—fixing a tricky bug, implementing a new feature, or refactoring existing code—you can submit it to multiple agents simultaneously. Each agent works independently in its own isolated container, approaching the problem from its unique perspective.
+
+For example, you might run the same task with Claude, Codex, and Gemini. Each agent reads your instructions, explores the codebase, and produces its own solution. Because they work in parallel, you get multiple candidate solutions in roughly the same time it would take to get one.
+
+### 2. Automatic Evaluation by Judge Agents
+
+Once the execution agents complete their work, CoderFlow can automatically launch **judge agents** to evaluate the results. Judges are AI agents configured specifically for code review and quality assessment.
+
+Multiple judges can evaluate each solution independently, examining:
+- Whether the implementation correctly addresses the requirements
+- Code quality, readability, and adherence to project conventions
+- Test coverage and whether existing tests still pass
+- Potential edge cases or issues the solution might miss
+
+The judges score each variant and can reach a consensus on which solution is best. This multi-judge approach reduces bias and provides more reliable evaluations.
+
+### 3. Feedback Loops
+
+Judges don't just score—they provide detailed feedback. When a judge identifies issues or improvements, that feedback can be automatically passed back to the execution agents. The agents then iterate on their solutions, addressing the judge's concerns.
+
+This creates an automated refinement cycle:
+1. Execution agents produce initial solutions
+2. Judge agents evaluate and provide feedback
+3. Execution agents improve their work based on feedback
+4. Judge agents re-evaluate until quality standards are met
+
+You can choose how many AI feedback rounds to follow, or manually trigger additional feedback as needed.
+
+### 4. Winner Selection and Review
+
+After evaluation completes, you select a winning variant—either manually by reviewing the options, or automatically based on judge scores. With a winner selected, you can:
+
+- **Review the code changes**: Examine exactly what the agent modified, added, or removed. The diff view quickly highlights all changes against the original codebase and allows yout to make adjustments. You can also review changes in an IDE (browser-based VS Code environment or your local IDE for deeper work).
+
+- **Run the application**: Launch the modified application directly from the container to test functionality. For web applications, CoderFlow provides URLs to access the running server. You can interact with the application, verify the fix works, and check for regressions.
+
+- **Provide additional feedback**: If the solution is close but needs adjustments, send follow-up instructions to the agent. It resumes work in the same container with full context of what it already did, making targeted improvements without starting over.
+
+### 5. Approve and Deploy
+
+When you're satisfied with the solution:
+
+1. **Approve the changes**: This commits the agent's modifications to your repository. CoderFlow generates a commit message summarizing the work, which you can customize before finalizing.
+
+2. **Choose your branch strategy**: Commit directly to the working branch, create a new feature branch, or open a pull request for team review.
+
+3. **Deploy** (optional): If your environment is configured with deployment pipelines, you can trigger deployment after the approval workflow, pushing the changes to staging or production.
+
+Every approval is logged with full traceability—who approved, when, what changed, and which agent produced the work.
+
+## Objectives
+
+**Objectives** are where you plan and draft your requirements before executing work. They provide a permanent home for your ideas as they evolve from initial concepts into well-defined specifications ready for AI agents to implement.
+
+For simple, well-understood tasks, you can create and launch a task directly. But for complex work—where requirements need refinement, or you're still forming your approach—starting with an objective gives you space to think and iterate.
+
+### Hierarchical Organization
+
+Objectives support multiple levels of nesting, letting you break down large initiatives into smaller, manageable pieces. The home page displays your objectives as a tree view, making it easy to see how work is organized and navigate between related items.
+
+For example, a high-level objective like "Modernize the reporting module" can be broken down into sub-objectives: "Update data models," "Redesign report templates," "Add export functionality." Each sub-objective can be further decomposed as needed.
+
+### The Iterative Workflow
+
+Objectives support an iterative approach to getting work done:
+
+1. **Draft your objective**: Write your initial requirements, attach relevant screenshots or documentation, and specify which environment and agents to use.
+
+2. **Launch a task**: When ready, launch a task from the objective. The task runs in its own container while the objective remains unchanged.
+
+3. **Evaluate and refine**: Review the agent's work. If the requirements weren't complete or specific enough, revise the objective based on what you learned.
+
+4. **Relaunch**: Submit another task with the refined requirements. Repeat until the work meets your expectations.
+
+This workflow means objectives serve as living documents that improve over time. Each task launched from an objective is independent, so you maintain a history of attempts and can compare approaches.
+
+## Tasks
+
+A **task** is a single unit of work executed by an AI agent. When you create a task—either directly or by launching from an objective—CoderFlow spins up an isolated container and runs the agent with your instructions.
+
+Tasks progress through a simple lifecycle:
+
+- **Pending**: Task is created and waiting to be queued
+- **Queued**: Waiting for an available container slot
+- **Running**: Agent is actively working on the task
+- **Completed**: Agent finished successfully
+- **Failed**: Agent encountered an error
+
+You can monitor running tasks in real-time, watching the agent's activity feed as it explores code, makes changes, and runs tests.
+
+### Staged Tasks
+
+For situations where you want to prepare a task but control exactly when the agent starts working, **staged tasks** launch the container and set up the environment but pause before the agent begins. This is useful for:
+
+- Manually adjusting the environment before execution
+- Coordinating task timing with external dependencies
+- Reviewing the setup before committing compute resources to agent work
+
+When ready, you start the staged task and the agent begins immediately in the pre-warmed container.
+
+## Pinned Items
+
+As you work with objectives and tasks, **pinning** helps you focus on what's currently active. Pin objectives you're actively planning and tasks you're evaluating. When work is complete, unpin items to move them out of your primary view.
+
+Your default view shows only pinned items—the objectives and tasks that need your attention right now. Switch to the "All" view when you need to reference historical work or revisit completed items.
+
+This approach keeps your workspace uncluttered while preserving full history. Nothing is deleted; completed work simply moves out of your active view until you need it again.

package/dist/web-ui/public/docs/getting-started/overview.md

@@ -0,0 +1,46 @@
+# Overview
+
+CoderFlow is an enterprise platform that runs autonomous engineering agents inside your infrastructure. Instead of suggesting code, agents compile, test, validate, and fix legacy systems end-to-end — delivering verified, ready-to-commit results and 5–10x productivity gains.
+
+## What is CoderFlow?
+
+CoderFlow is a client-server system designed for enterprise teams working with complex codebases—including legacy systems like IBM i, COBOL, and RPG code. Rather than requiring developers to manually edit code and run tests, CoderFlow:
+
+- Submits coding tasks to AI agents (Claude, Codex, Gemini) running in isolated Docker containers
+- Lets agents execute code, compile, test, and validate changes automatically
+- Supports both headless execution (submit once, review results later) and interactive sessions (work within containers for guided work)
+- Manages multi-repository workspaces with build pipelines and test suites
+- Allows developers to review, iterate, and approve changes before committing
+
+Key benefits:
+- **Full Build-Test-Fix Loops**: Agents don't just write code—they compile, test, and fix until validation passes
+- **On-Premises Execution**: Runs inside your infrastructure with your security controls
+- **Legacy System Support**: Handles IBM i, RPG, COBOL, and modern stacks (Node.js, Java, etc.)
+- **Parallel Multi-Agent Execution**: Run multiple agents concurrently with automated result comparison
+- **Developer Orchestration**: You control objectives; agents execute; you approve results
+- **Skills Management**: Create reusable prompt-based skills and assign them to environments
+
+## How It Works
+
+1. **Create a Task**: You define an objective (e.g., "refactor function X" or "add feature Y") via CLI, Web UI, or API
+2. **Agent Executes in Container**: The server spins up a Docker container with your codebase, repositories, and build environment
+3. **Full Validation Loop**: The agent makes changes, compiles, runs tests, and fixes issues until all validations pass
+4. **Review Results**: Check the agent's work—summary, changes, test results, and commit message—all in one place
+5. **Approve & Commit**: Once satisfied, apply changes directly to your repositories
+
+The entire process is transparent: you can watch the agent's progress in real-time or review the complete activity log afterward.
+
+## Key Features
+
+- **Environments**: Pre-configured Docker images with your repositories, build tools, and dependencies
+- **Tasks**: Discrete coding objectives that agents execute autonomously or interactively
+- **Parallel Agents**: Run multiple agents on different tasks or the same task for comparison
+- **AI Review & Judge Agents**: Automated evaluation of agent results for quality and correctness
+- **Container Isolation**: Each task runs in its own secure, isolated container with time limits
+- **Task Queueing**: Automatic queue management with concurrency limits (default: 8 concurrent agents)
+- **Real-Time Monitoring**: Watch agent progress, activity feeds, and live logs
+- **Multi-Repository Support**: Clone and sync multiple Git repositories per environment
+- **Build & Test Automation**: Run build scripts, tests, and validation checks as part of task execution
+- **Result Delivery**: Summaries, file diffs, test reports, and ready-to-commit patches
+- **Application Servers**: Optional in-container app server for testing web interfaces
+- **Scheduled Image Rebuilds**: Keep Docker images fresh with automated rebuilds on a schedule