seed-qwen-ai 1.0.0

package/README.md

@@ -0,0 +1,309 @@
+# SEED-Qwen
+
+**Typed Project Incubator** for Qwen CLI — guided ideation through graduation into buildable projects.
+
+---
+
+## What is SEED?
+
+SEED takes raw ideas through structured, type-aware exploration and produces comprehensive `PLANNING.md` documents ready for building.
+
+```
+Raw Idea → SEED → PLANNING.md → PAUL → Built Project
+```
+
+---
+
+## Quick Start
+
+### Install
+
+```bash
+npx seed-qwen-ai
+```
+
+Or specify location:
+
+```bash
+# Global (all projects)
+npx seed-qwen-ai --global
+
+# Local (current project)
+npx seed-qwen-ai --local
+```
+
+### Start Ideation
+
+```bash
+/seed
+```
+
+### Launch with PAUL
+
+```bash
+/seed launch
+```
+
+This graduates your project AND initializes PAUL in one step — no re-asking questions.
+
+---
+
+## Project Types (5)
+
+| Type | Rigor | Purpose |
+|------|-------|---------|
+| **Application** | Deep | Software with UI, data model, API, deployment |
+| **Workflow** | Standard | Claude Code commands, hooks, skills |
+| **Client** | Standard | Client websites — business context, conversion |
+| **Utility** | Tight | Small tools, scripts, single-purpose |
+| **Campaign** | Creative | Content, marketing, launches |
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/seed` | Start guided ideation (default) |
+| `/seed graduate` | Move to `apps/` with git repo + README |
+| `/seed launch` | Graduate + initialize PAUL (headless) |
+| `/seed status` | Show all projects in pipeline |
+| `/seed add-type` | Create custom project type |
+
+---
+
+## The SEED → PAUL Pipeline
+
+### Step 1: Ideation (`/seed`)
+
+```
+1. Select project type
+2. Guided conversation (type-specific)
+3. Generate PLANNING.md
+```
+
+### Step 2: Graduation (`/seed graduate`)
+
+```
+1. Quality gate check
+2. Move to apps/{name}/
+3. Git init + README
+```
+
+### Step 3: Launch (`/seed launch`)
+
+```
+1. All Graduation steps
+2. PAUL initialized headlessly
+3. PLANNING.md → ROADMAP.md, PROJECT.md
+4. Ready for /paul/plan
+```
+
+---
+
+## File Structure
+
+```
+projects/
+└── {project-name}/
+    └── PLANNING.md    # Generated during ideation
+
+apps/
+└── {project-name}/
+    ├── PLANNING.md    # Copied from projects/
+    ├── README.md      # Generated during graduation
+    └── .paul/         # Created by /seed launch
+        ├── PROJECT.md
+        ├── ROADMAP.md
+        └── STATE.md
+```
+
+---
+
+## Example Session
+
+```bash
+# Start ideation
+/seed
+
+# Select: Application
+# Answer guided questions...
+# PLANNING.md generated
+
+# Graduate and launch
+/seed launch my-app
+
+# Now in apps/my-app/ with PAUL ready
+/paul/plan    # Create first executable plan
+/paul/apply   # Build it
+/paul/unify   # Close loop
+```
+
+---
+
+## Custom Project Types
+
+Add your own types:
+
+```bash
+/seed add-type
+```
+
+Creates:
+- `~/.qwen/seed-framework/data/{type}/config.md`
+- `~/.qwen/seed-framework/data/{type}/guide.md`
+- `~/.qwen/seed-framework/data/{type}/skill-loadout.md`
+
+---
+
+## Quality Gates
+
+Before graduation, SEED verifies:
+
+**Universal:**
+- Problem statement clear
+- Target users defined
+- Phases outlined
+- Next actions clear
+
+**Type-Specific:**
+- Application: Tech stack resolved, data model defined
+- Workflow: Trigger mechanism clear
+- Client: Conversion path defined
+- Utility: Single purpose (no scope creep)
+- Campaign: Measurable goal, timeline set
+
+---
+
+## Integration with PAUL-Qwen
+
+SEED works standalone or with PAUL-Qwen:
+
+**Standalone:**
+```bash
+/seed graduate    # Just create the project
+# Build however you want
+```
+
+**With PAUL:**
+```bash
+/seed launch      # Graduate + PAUL init
+/paul/plan        # Start structured build
+```
+
+---
+
+## Installation Options
+
+### Interactive (Default)
+
+```bash
+npx seed-qwen
+```
+
+### Non-Interactive
+
+```bash
+# Global
+npx seed-qwen --global
+
+# Local
+npx seed-qwen --local
+
+# Custom path
+npx seed-qwen --config-dir ~/.qwen-custom
+```
+
+### Help
+
+```bash
+npx seed-qwen --help
+```
+
+---
+
+## Updating
+
+```bash
+npx seed-qwen@latest
+```
+
+---
+
+## Comparison: SEED vs Ad-Hoc Planning
+
+| Aspect | Ad-Hoc | SEED |
+|--------|--------|------|
+| Structure | None | Type-guided |
+| Output | Notes, fragments | Structured PLANNING.md |
+| Graduation | Manual | Automated |
+| PAUL Handoff | Re-asks questions | Headless (zero re-asking) |
+| Quality | Variable | Gate-checked |
+
+---
+
+## When to Use SEED
+
+### Good Fit
+
+- New project from scratch
+- Vague idea needs shaping
+- Want structured plan before building
+- Team alignment needed
+
+### Overkill
+
+- Quick scripts (use Utility type anyway)
+- Experiments/prototypes
+- Already have detailed spec
+
+---
+
+## Troubleshooting
+
+### Commands Not Found
+
+```bash
+# Verify installation
+ls ~/.qwen/commands/seed/
+
+# Restart Qwen CLI
+```
+
+### PLANNING.md Incomplete
+
+Run quality gate manually:
+```bash
+/seed graduate    # Will show what's missing
+```
+
+---
+
+## Contributing
+
+1. Fork the repo
+2. Make changes
+3. Test with real projects
+4. Submit PR
+
+**GitHub:** https://github.com/tyler1350/seed-qwen
+
+---
+
+## License
+
+MIT License — see LICENSE file.
+
+---
+
+## Credits
+
+SEED-Qwen is a port of the [SEED Framework](https://github.com/ChristopherKahler/seed) by Chris Kahler, adapted for Qwen CLI.
+
+Part of the PAUL ecosystem:
+- **SEED** — Project incubator (ideation → planning)
+- **PAUL** — Project orchestration (plan → apply → unify)
+
+---
+
+*SEED-Qwen v1.0 | For Qwen CLI | Typed Project Incubator*

package/bin/install.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${cyan}  ███████╗██╗  ██╗ █████╗ ██████╗ ${reset}
+${cyan}  ██╔════╝╚██╗██╔╝██╔══██╗██╔══██╗${reset}
+${cyan}  █████╗   ╚███╔╝ ███████║██████╔╝${reset}
+${cyan}  ██╔══╝   ██╔██╗ ██╔══██║██╔══██╗${reset}
+${cyan}  ██║     ██╔╝ ██╗██║  ██║██║  ██║${reset}
+${cyan}  ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝${reset}
+
+  ${cyan}SEED-Qwen${reset} Framework ${dim}v${pkg.version}${reset}
+  Typed Project Incubator for Qwen CLI
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    return configDirArg.split('=')[1];
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx seed-qwen [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}              Install globally (to Qwen config directory)
+    ${cyan}-l, --local${reset}               Install locally (to ./.qwen in current directory)
+    ${cyan}-c, --config-dir <path>${reset}   Specify custom Qwen config directory
+    ${cyan}-h, --help${reset}                Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install to default ~/.qwen directory${reset}
+    npx seed-qwen --global
+
+    ${dim}# Install to custom config directory${reset}
+    npx seed-qwen --global --config-dir ~/.qwen-custom
+
+    ${dim}# Install to current project only${reset}
+    npx seed-qwen --local
+
+  ${yellow}What gets installed:${reset}
+    commands/seed/     - Slash commands (/seed, /seed/graduate, /seed/launch)
+    seed-framework/    - Tasks, data types, templates, checklists
+`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory, replacing paths in .md files
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix);
+    } else if (entry.name.endsWith('.md')) {
+      // Replace ~/.qwen/ with the appropriate prefix in markdown files
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.qwen\//g, pathPrefix);
+      fs.writeFileSync(destPath, content);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install to the specified directory
+ */
+function install(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.QWEN_CONFIG_DIR);
+  const defaultGlobalDir = configDir || path.join(os.homedir(), '.qwen');
+  const qwenDir = isGlobal
+    ? defaultGlobalDir
+    : path.join(process.cwd(), '.qwen');
+
+  const locationLabel = isGlobal
+    ? qwenDir.replace(os.homedir(), '~')
+    : qwenDir.replace(process.cwd(), '.');
+
+  // Path prefix for file references
+  const pathPrefix = isGlobal
+    ? (configDir ? `${qwenDir}/` : '~/.qwen/')
+    : './.qwen/';
+
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+  // Create commands directory
+  const commandsDir = path.join(qwenDir, 'commands');
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  // Copy commands/seed to commands/seed
+  const commandsSrc = path.join(src, 'commands', 'seed');
+  const commandsDest = path.join(commandsDir, 'seed');
+  copyWithPathReplacement(commandsSrc, commandsDest, pathPrefix);
+  console.log(`  ${green}✓${reset} Installed commands/seed`);
+
+  // Copy seed-framework/ to qwen/seed-framework/
+  const frameworkDest = path.join(qwenDir, 'seed-framework');
+  fs.mkdirSync(frameworkDest, { recursive: true });
+
+  const srcDirs = ['tasks', 'data', 'templates', 'checklists'];
+  for (const dir of srcDirs) {
+    const dirSrc = path.join(src, dir);
+    const dirDest = path.join(frameworkDest, dir);
+    if (fs.existsSync(dirSrc)) {
+      copyWithPathReplacement(dirSrc, dirDest, pathPrefix);
+    }
+  }
+  console.log(`  ${green}✓${reset} Installed seed-framework`);
+
+  console.log(`
+  ${green}Done!${reset} Launch Qwen CLI and run ${cyan}/seed${reset}.
+`);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.QWEN_CONFIG_DIR);
+  const globalPath = configDir || path.join(os.homedir(), '.qwen');
+  const globalLabel = globalPath.replace(os.homedir(), '~');
+
+  console.log(`  ${yellow}Where would you like to install?${reset}
+
+  ${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(./.qwen)${reset} - this project only
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice !== '2';
+    install(isGlobal);
+  });
+}
+
+// Main
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (explicitConfigDir && hasLocal) {
+  console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
+  process.exit(1);
+} else if (hasGlobal) {
+  install(true);
+} else if (hasLocal) {
+  install(false);
+} else {
+  promptLocation();
+}

package/checklists/planning-quality.md

@@ -0,0 +1,81 @@
+# Planning Quality Checklist
+
+**Purpose:** Quality gate before graduation or launch.
+
+---
+
+## Universal Checks (All Types)
+
+- [ ] Problem statement is clear and specific
+- [ ] Target users/audience defined
+- [ ] At least 2 phases outlined
+- [ ] Next actions are clear
+- [ ] No "TBD" in critical sections
+
+---
+
+## Type-Specific Checks
+
+### Application
+
+- [ ] Tech stack fully resolved (no "React or Vue")
+- [ ] Data entities defined (3-5 core entities)
+- [ ] API routes outlined
+- [ ] Deployment target specified
+- [ ] Security considerations addressed
+
+### Workflow
+
+- [ ] Trigger mechanism clear
+- [ ] Integration points defined
+- [ ] Error handling approach specified
+- [ ] Usage examples provided
+
+### Client
+
+- [ ] Business goal is measurable
+- [ ] Target audience is specific
+- [ ] Conversion path defined
+- [ ] Content requirements listed
+- [ ] Timeline realistic
+
+### Utility
+
+- [ ] Single purpose (not expanding)
+- [ ] Input/output clearly defined
+- [ ] Usage examples work
+- [ ] Edge cases considered
+- [ ] Can be built in one session
+
+### Campaign
+
+- [ ] Goal is measurable (number, not "awareness")
+- [ ] Timeline has specific dates
+- [ ] Content types and quantities defined
+- [ ] Channels selected
+- [ ] Success metrics identified
+
+---
+
+## Pass/Fail Decision
+
+**Pass:** All universal checks + all type-specific checks
+
+**Conditional Pass:** 1-2 minor gaps, can be filled during build
+
+**Fail:** Major gaps (problem unclear, tech stack TBD, no phases)
+
+---
+
+## If Fail
+
+Offer user:
+1. Continue ideation to fill gaps
+2. Graduate anyway (at own risk)
+3. Switch to simpler type (e.g., Application → Utility)
+
+---
+
+## If Pass
+
+Proceed to graduation or launch.

package/data/application/config.md

@@ -0,0 +1,29 @@
+# Application Type Config
+
+**Rigor:** Deep
+**Description:** Software applications with UI, data model, API, and deployment
+
+## Sections Required
+1. Problem Statement
+2. Target Users
+3. Tech Stack
+4. Data Model
+5. API Surface
+6. UI/UX Needs
+7. Deployment Strategy
+8. Security Considerations
+9. Phase Breakdown
+10. Success Criteria
+
+## Demeanor
+- Thorough and architectural
+- Don't rush decisions
+- Challenge assumptions
+- Ensure scalability considerations
+
+## Minimum for Graduation
+- Tech stack fully resolved (no "TBD")
+- Data entities defined
+- API routes outlined
+- Phase breakdown with 2+ phases
+- Deployment target specified