@cliangdev/flux-plugin 0.2.0-dev.e34d43b → 0.2.0-dev.edce79d

package/commands/prd.md

@@ -1,7 +1,7 @@
 ---
 name: flux:prd
 description: Create comprehensive PRDs through discovery, research, and guided writing
-allowed-tools: mcp__flux__*, AskUserQuestion, Read, Glob, Grep, Task, WebSearch
+allowed-tools: mcp__flux__*, AskUserQuestion, Read, Write, Glob, Grep, Task, WebSearch, Bash
 ---
 
 # PRD Creation Command
@@ -216,6 +216,181 @@ Use AskUserQuestion:
 
 **Goal**: Gather technical context to make the PRD specific and implementable.
 
+#### Step 2.0: Greenfield Detection & Essential Setup
+
+**Before exploring the codebase, check if this is a greenfield project.**
+
+##### Detection
+
+Check for project indicators using Glob:
+```
+- .git directory exists?
+- package.json / go.mod / pyproject.toml / Cargo.toml / etc.?
+- src/ or lib/ directories with code files?
+```
+
+**If ALL indicators are missing → Greenfield project → Trigger setup flow**
+
+##### Essential Setup Flow
+
+When greenfield is detected, present:
+
+```
+This looks like a new project without existing setup.
+
+Before we create the PRD, let's establish the foundation:
+
+**Git Setup**
+- Initialize repository with .gitignore for {detected/chosen tech stack}
+- Create branching structure: main + develop (git flow ready)
+- Initial commit with project structure
+
+**Project Structure** (based on {project type from Phase 1})
+{Show recommended minimal structure}
+
+**Package Setup**
+- Initialize {package.json / pyproject.toml / go.mod / etc.}
+
+Proceed with this setup?
+```
+
+Use AskUserQuestion:
+- "Yes, set up essentials" (Recommended)
+- "Customize setup first"
+- "Skip - I'll set up manually"
+
+##### Essential Setup by Project Type
+
+| Project Type | Git | Structure | Package Init |
+|--------------|-----|-----------|--------------|
+| **Web App (Node)** | .gitignore (node) | `src/`, `tests/`, `public/` | package.json |
+| **Web App (Python)** | .gitignore (python) | `src/`, `tests/` | pyproject.toml |
+| **CLI Tool (Node)** | .gitignore (node) | `src/`, `bin/`, `tests/` | package.json with bin |
+| **CLI Tool (Go)** | .gitignore (go) | `cmd/`, `internal/`, `pkg/` | go.mod |
+| **API/Backend** | .gitignore (lang) | `src/`, `tests/`, `config/` | Language-specific |
+| **Library** | .gitignore (lang) | `src/`, `tests/`, `examples/` | Language-specific |
+
+##### Executing Essential Setup
+
+When user confirms, execute via Bash:
+
+```bash
+# Git initialization
+git init
+git checkout -b main
+git checkout -b develop
+
+# Create .gitignore (use appropriate template for language)
+# Create initial directory structure (mkdir -p)
+# Initialize package manager (npm init -y / go mod init / etc.)
+
+# Initial commit
+git add .
+git commit -m "Initial project setup
+
+- Initialize git with main/develop branches
+- Add .gitignore for {language}
+- Create project structure
+- Initialize {package manager}
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+# Return to develop for feature work
+git checkout develop
+```
+
+##### Foundation PRD Offer
+
+After essential setup completes (or if user skipped), offer comprehensive setup as a tracked PRD:
+
+```
+Foundation is ready. Would you like to track additional setup as a PRD?
+
+A Foundation PRD would cover:
+- CI/CD pipeline (GitHub Actions / GitLab CI)
+- Linting & formatting (ESLint+Prettier / Biome / Ruff)
+- Testing framework setup
+- Environment configuration (.env patterns)
+- Pre-commit hooks
+
+This gets tracked in Flux so you can implement it systematically.
+```
+
+Use AskUserQuestion:
+- "Create Foundation PRD" - Creates PRD with [tag: foundation], then continues to feature PRD
+- "Skip - continue to feature PRD" (Recommended for simple projects)
+
+##### Foundation PRD Template
+
+If user wants a Foundation PRD, create it with this structure:
+
+```markdown
+# Project Foundation
+
+> **Tag**: foundation
+> **Depends on**: None
+> **Blocks**: All feature PRDs
+
+## Problem
+
+New projects without proper tooling lead to inconsistent code quality,
+manual testing overhead, and deployment friction.
+
+## Users
+
+Developers working on this codebase.
+
+## Solution
+
+Establish development infrastructure: CI/CD, code quality tools, testing
+framework, and environment management.
+
+## Features
+
+### P0: Must Have
+
+- **CI Pipeline**: Automated testing on push/PR
+  - **What**: GitHub Actions workflow for test/lint/build
+  - **Not**: Deployment pipelines, complex matrix builds
+  - **Acceptance Criteria**:
+    - [ ] Push to any branch triggers CI
+    - [ ] PR cannot merge if CI fails
+    - [ ] CI runs tests, linting, and type checking
+
+- **Code Quality**: Linting and formatting
+  - **What**: {ESLint+Prettier / Biome / Ruff} with pre-commit hooks
+  - **Not**: Custom rules beyond standard configs
+  - **Acceptance Criteria**:
+    - [ ] Lint command runs without errors
+    - [ ] Pre-commit hook prevents unlinted commits
+    - [ ] Editor integration documented
+
+- **Testing Framework**: Test infrastructure
+  - **What**: {Jest/Vitest / Pytest / Go test} with coverage
+  - **Not**: E2E tests, integration infrastructure
+  - **Acceptance Criteria**:
+    - [ ] Test command runs and reports coverage
+    - [ ] Example test demonstrates patterns
+    - [ ] Coverage threshold set (70%)
+
+### P1: Should Have
+
+- **Environment Config**: .env management
+- **Documentation**: README with setup instructions
+
+### Out of Scope
+- Deployment pipelines
+- Production infrastructure
+- Monitoring/observability
+```
+
+After creating Foundation PRD:
+1. Save it with `tag: foundation`
+2. Continue to the user's feature PRD
+3. Set feature PRD's `Depends on: {Foundation PRD ref}`
+
+---
+
 #### Step 2.1: Codebase Research
 
 Check if there's an existing codebase to analyze:

package/manifest.json

@@ -7,7 +7,8 @@
       "agent-creator",
       "epic-template",
       "flux-orchestrator",
-      "prd-writer"
+      "prd-writer",
+      "ux-ui-design"
     ],
     "agents": ["coder.md", "critic.md", "researcher.md", "verifier.md"],
     "hooks": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cliangdev/flux-plugin",
-  "version": "0.2.0-dev.e34d43b",
+  "version": "0.2.0-dev.edce79d",
   "description": "Claude Code plugin for AI-first workflow orchestration with MCP server",
   "type": "module",
   "main": "./dist/server/index.js",
@@ -17,9 +17,11 @@
   ],
   "scripts": {
     "dev": "bun run src/server/index.ts",
-    "build": "bun build --compile --outfile bin/flux-server src/server/index.ts && bun build --compile --outfile bin/flux-status src/status-line/index.ts",
+    "build": "bun build --compile --outfile bin/flux-server src/server/index.ts && bun build --compile --outfile bin/flux-status src/status-line/index.ts && bun build --compile --outfile bin/flux-dashboard src/dashboard/server.ts",
     "build:server": "bun build --compile --outfile bin/flux-server src/server/index.ts",
     "build:status": "bun build --compile --outfile bin/flux-status src/status-line/index.ts",
+    "build:dashboard": "bun build --compile --outfile bin/flux-dashboard src/dashboard/server.ts",
+    "dev:dashboard": "bun run src/dashboard/server.ts",
     "validate": "node scripts/validate-structure.cjs",
     "test:integration": "bun test scripts/__tests__/integration.test.ts --timeout 120000",
     "prepublishOnly": "bun run validate && bun run test:integration",

package/skills/prd-writer/SKILL.md

@@ -497,6 +497,190 @@ After PRD approval, ask based on project type:
 
 **Goal**: Gather technical context to inform the PRD.
 
+#### Step 2.0: Greenfield Detection & Setup
+
+**Before exploring the codebase, check if this is a greenfield project.**
+
+##### Detection
+
+Check for project indicators:
+```
+- .git directory exists?
+- package.json / go.mod / pyproject.toml / Cargo.toml / etc.?
+- src/ or lib/ directories with code files?
+- Any meaningful source files?
+```
+
+**If ALL indicators are missing → Greenfield project → Trigger setup flow**
+
+##### Essential Setup Flow
+
+When greenfield is detected, present:
+
+```
+This looks like a new project without existing setup.
+
+Before we create the PRD, let's establish the foundation:
+
+**Git Setup**
+- Initialize repository with .gitignore
+- Create branching structure: main + develop (git flow ready)
+- Initial commit with project structure
+
+**Project Structure** (based on {detected project type from Phase 1})
+{Show recommended minimal structure for the project type}
+
+**Package Setup**
+- Initialize {package.json / pyproject.toml / go.mod / etc.}
+- Add essential dev dependencies
+
+Proceed with this setup?
+```
+
+Use AskUserQuestion:
+- "Yes, set up essentials" (Recommended)
+- "Customize setup first"
+- "Skip - I'll set up manually"
+
+##### Essential Setup by Project Type
+
+| Project Type | Git | Structure | Package Init |
+|--------------|-----|-----------|--------------|
+| **Web App (Node)** | .gitignore (node) | `src/`, `tests/`, `public/` | package.json with scripts |
+| **Web App (Python)** | .gitignore (python) | `src/`, `tests/` | pyproject.toml |
+| **CLI Tool (Node)** | .gitignore (node) | `src/`, `bin/`, `tests/` | package.json with bin |
+| **CLI Tool (Go)** | .gitignore (go) | `cmd/`, `internal/`, `pkg/` | go.mod |
+| **API/Backend** | .gitignore (lang) | `src/`, `tests/`, `config/` | Language-specific |
+| **Library** | .gitignore (lang) | `src/`, `tests/`, `examples/` | Language-specific |
+
+##### Executing Essential Setup
+
+When user confirms, execute these commands:
+
+```bash
+# Git initialization
+git init
+git checkout -b main
+git checkout -b develop
+
+# Create .gitignore (language-appropriate)
+# Create initial directory structure
+# Initialize package manager
+
+# Initial commit
+git add .
+git commit -m "Initial project setup
+
+- Initialize git with main/develop branches
+- Add .gitignore for {language}
+- Create project structure
+- Initialize {package manager}
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+# Return to develop for feature work
+git checkout develop
+```
+
+##### Foundation PRD Offer
+
+After essential setup completes (or if user skipped), offer comprehensive setup as a tracked PRD:
+
+```
+Foundation is ready. Would you like to track additional setup as a PRD?
+
+A Foundation PRD would include:
+- CI/CD pipeline (GitHub Actions / GitLab CI)
+- Linting & formatting (ESLint+Prettier / Ruff / etc.)
+- Testing framework setup
+- Environment configuration (.env patterns)
+- Pre-commit hooks
+- Documentation structure
+
+This gets tracked in Flux so you can implement it systematically.
+```
+
+Use AskUserQuestion:
+- "Create Foundation PRD" - Creates PRD with [tag: foundation], then continues to feature PRD
+- "Skip - continue to feature PRD" (Recommended for simple projects)
+
+##### Foundation PRD Template
+
+If user wants a Foundation PRD, create it with this structure:
+
+```markdown
+# Project Foundation
+
+> **Tag**: foundation
+> **Depends on**: None
+> **Blocks**: All feature PRDs
+
+## Problem
+
+New projects without proper tooling lead to inconsistent code quality,
+manual testing overhead, and deployment friction.
+
+## Users
+
+Developers working on this codebase.
+
+## Solution
+
+Establish development infrastructure: CI/CD, code quality tools, testing
+framework, and environment management.
+
+## Features
+
+### P0: Must Have
+
+- **CI Pipeline**: Automated testing on push/PR
+  - **What**: GitHub Actions (or GitLab CI) workflow for test/lint/build
+  - **Not**: Deployment pipelines (separate PRD), complex matrix builds
+  - **Acceptance Criteria**:
+    - [ ] Push to any branch triggers CI
+    - [ ] PR cannot merge if CI fails
+    - [ ] CI runs tests, linting, and type checking
+
+- **Code Quality**: Linting and formatting
+  - **What**: {ESLint+Prettier / Biome / Ruff / etc.} with pre-commit hooks
+  - **Not**: Custom rules beyond standard configs
+  - **Acceptance Criteria**:
+    - [ ] `{lint command}` runs without errors on codebase
+    - [ ] Pre-commit hook prevents committing unlinted code
+    - [ ] Editor integration documented in README
+
+- **Testing Framework**: Test infrastructure
+  - **What**: {Jest/Vitest / Pytest / Go test} configured with coverage
+  - **Not**: E2E tests, integration test infrastructure
+  - **Acceptance Criteria**:
+    - [ ] `{test command}` runs and reports coverage
+    - [ ] Example test file demonstrates testing patterns
+    - [ ] Coverage threshold configured (suggest 70%)
+
+### P1: Should Have
+
+- **Environment Config**: .env management
+  - .env.example with all required variables documented
+  - Validation on startup for required env vars
+
+- **Documentation**: README and contributing guide
+  - Setup instructions
+  - Development workflow
+  - How to run tests
+
+### Out of Scope
+- Deployment pipelines (separate DevOps PRD)
+- Production infrastructure
+- Monitoring and observability
+```
+
+After creating Foundation PRD, continue to the user's feature PRD with proper dependency:
+- Set feature PRD's `Depends on: {Foundation PRD ref}`
+
+---
+
+#### Step 2.1: Codebase Exploration
+
 Spawn a research agent to:
 1. **Explore the codebase** (if exists):
    - Project structure and patterns