up-cli 0.1.0__py3-none-any.whl

up/__init__.py

@@ -0,0 +1,3 @@
+"""up - AI-powered project scaffolding CLI."""
+
+__version__ = "0.1.0"

up/cli.py

@@ -0,0 +1,28 @@
+"""Main CLI entry point for up."""
+
+import click
+from rich.console import Console
+
+from up.commands.init import init_cmd
+from up.commands.new import new_cmd
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="up")
+def main():
+    """up - AI-powered project scaffolding.
+
+    Create projects with built-in docs, learn, and product-loop systems
+    for Claude Code and Cursor AI.
+    """
+    pass
+
+
+main.add_command(init_cmd, name="init")
+main.add_command(new_cmd, name="new")
+
+
+if __name__ == "__main__":
+    main()

up/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands module."""

up/commands/init.py

@@ -0,0 +1,71 @@
+"""up init - Initialize up systems in existing project."""
+
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from up.templates import scaffold_project
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--ai",
+    type=click.Choice(["claude", "cursor", "both"]),
+    default="both",
+    help="Target AI assistant (claude, cursor, or both)",
+)
+@click.option(
+    "--systems",
+    "-s",
+    multiple=True,
+    type=click.Choice(["docs", "learn", "loop", "all"]),
+    default=["all"],
+    help="Systems to initialize",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Overwrite existing files",
+)
+def init_cmd(ai: str, systems: tuple, force: bool):
+    """Initialize up systems in the current directory."""
+    cwd = Path.cwd()
+
+    console.print(Panel.fit(
+        f"[bold blue]up init[/] - Initializing in [cyan]{cwd.name}[/]",
+        border_style="blue"
+    ))
+
+    # Determine which systems to install
+    if "all" in systems:
+        systems = ("docs", "learn", "loop")
+
+    # Run scaffolding
+    scaffold_project(
+        target_dir=cwd,
+        ai_target=ai,
+        systems=list(systems),
+        force=force,
+    )
+
+    console.print("\n[green]✓[/] Initialization complete!")
+    _print_next_steps(systems)
+
+
+def _print_next_steps(systems: tuple):
+    """Print next steps after initialization."""
+    console.print("\n[bold]Next steps:[/]")
+
+    if "docs" in systems:
+        console.print("  • Edit [cyan]docs/roadmap/vision/PRODUCT_VISION.md[/]")
+
+    if "learn" in systems:
+        console.print("  • Run [cyan]/learn auto[/] to analyze your project")
+
+    if "loop" in systems:
+        console.print("  • Run [cyan]/product-loop[/] to start development")

up/commands/new.py

@@ -0,0 +1,72 @@
+"""up new - Create a new project with up systems."""
+
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from up.templates import scaffold_project
+
+console = Console()
+
+
+@click.command()
+@click.argument("name")
+@click.option(
+    "--ai",
+    type=click.Choice(["claude", "cursor", "both"]),
+    default="both",
+    help="Target AI assistant",
+)
+@click.option(
+    "--template",
+    "-t",
+    type=click.Choice(["minimal", "standard", "full"]),
+    default="standard",
+    help="Project template",
+)
+def new_cmd(name: str, ai: str, template: str):
+    """Create a new project with up systems.
+
+    NAME is the project directory name.
+    """
+    target = Path.cwd() / name
+
+    if target.exists():
+        console.print(f"[red]Error:[/] Directory '{name}' already exists")
+        raise SystemExit(1)
+
+    console.print(Panel.fit(
+        f"[bold blue]up new[/] - Creating [cyan]{name}[/]",
+        border_style="blue"
+    ))
+
+    # Create directory
+    target.mkdir(parents=True)
+
+    # Determine systems based on template
+    systems = _get_systems_for_template(template)
+
+    # Scaffold
+    scaffold_project(
+        target_dir=target,
+        ai_target=ai,
+        systems=systems,
+        force=True,
+    )
+
+    console.print(f"\n[green]✓[/] Project created at [cyan]{target}[/]")
+    console.print(f"\n  cd {name}")
+    console.print("  up init --help")
+
+
+def _get_systems_for_template(template: str) -> list:
+    """Get systems list based on template."""
+    templates = {
+        "minimal": ["docs"],
+        "standard": ["docs", "learn", "loop"],
+        "full": ["docs", "learn", "loop"],
+    }
+    return templates.get(template, ["docs"])

up/templates/__init__.py

@@ -0,0 +1,54 @@
+"""Templates module for up scaffolding."""
+
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+
+def scaffold_project(
+    target_dir: Path,
+    ai_target: str,
+    systems: list,
+    force: bool = False,
+) -> None:
+    """Scaffold a project with selected systems."""
+    from up.templates.docs import create_docs_system
+    from up.templates.learn import create_learn_system
+    from up.templates.loop import create_loop_system
+    from up.templates.docs_skill import create_docs_skill
+    from up.templates.config import create_config_files
+
+    # Create base structure
+    _create_base_structure(target_dir, ai_target)
+
+    # Create config files
+    create_config_files(target_dir, ai_target, force)
+
+    # Create selected systems
+    if "docs" in systems:
+        console.print("  [dim]Creating docs system...[/]")
+        create_docs_system(target_dir, force)
+        create_docs_skill(target_dir, ai_target, force)
+
+    if "learn" in systems:
+        console.print("  [dim]Creating learn system...[/]")
+        create_learn_system(target_dir, ai_target, force)
+
+    if "loop" in systems:
+        console.print("  [dim]Creating product-loop system...[/]")
+        create_loop_system(target_dir, ai_target, force)
+
+
+def _create_base_structure(target_dir: Path, ai_target: str) -> None:
+    """Create base directory structure."""
+    dirs = ["src", "tests", "docs"]
+
+    # AI-specific directories
+    if ai_target in ("claude", "both"):
+        dirs.append(".claude/skills")
+    if ai_target in ("cursor", "both"):
+        dirs.append(".cursor")
+
+    for d in dirs:
+        (target_dir / d).mkdir(parents=True, exist_ok=True)

up/templates/config/__init__.py

@@ -0,0 +1,86 @@
+"""Config file templates for Claude and Cursor."""
+
+from pathlib import Path
+
+
+def create_config_files(target_dir: Path, ai_target: str, force: bool = False) -> None:
+    """Create config files for AI assistants."""
+    if ai_target in ("claude", "both"):
+        _create_claude_md(target_dir, force)
+    if ai_target in ("cursor", "both"):
+        _create_cursorrules(target_dir, force)
+
+
+def _write_file(path: Path, content: str, force: bool) -> None:
+    if path.exists() and not force:
+        return
+    path.write_text(content)
+
+
+def _create_claude_md(target_dir: Path, force: bool) -> None:
+    """Create CLAUDE.md for Claude Code."""
+    content = """# Project Guide
+
+## On Session Start
+
+1. Read `docs/CONTEXT.md` for current state
+2. Check `docs/handoff/LATEST.md` for recent work
+3. Use `docs/INDEX.md` to find relevant docs
+4. Apply rules below
+
+## AI Vibing Coding Rules
+
+### Golden Rules
+1. **Vision before code** - Understand architecture first
+2. **One thing at a time** - Numbered, atomic requests
+3. **Verify immediately** - Test after each change
+4. **Context is king** - Use @file references
+5. **Frustration = signal** - Change approach when stuck
+
+### Request Format
+```
+1. [ACTION] [TARGET] [CONTEXT]
+2. [ACTION] [TARGET] [CONTEXT]
+```
+
+### 2-Failure Rule
+If something fails twice:
+1. Provide more context
+2. Reference specific files
+3. Break into smaller steps
+
+## Skills
+
+| Skill | When to Use |
+|-------|-------------|
+| `/docs` | Create/manage documentation |
+| `/learn` | Research and create PRD |
+| `/product-loop` | Development with SESRC |
+
+## Auto-Triggers
+
+- New feature → `/learn auto`
+- Start coding → `/product-loop`
+- Need docs → `/docs new [type]`
+- Session end → Update `docs/handoff/LATEST.md`
+"""
+    _write_file(target_dir / "CLAUDE.md", content, force)
+
+
+def _create_cursorrules(target_dir: Path, force: bool) -> None:
+    """Create .cursorrules for Cursor AI."""
+    content = """# Cursor Rules
+
+## Skills Available
+
+- /docs - Documentation management
+- /learn - Research and PRD
+- /product-loop - SESRC development
+
+## Workflow
+
+1. Research: /learn auto
+2. Build: /product-loop
+3. Document: /docs new
+"""
+    _write_file(target_dir / ".cursorrules", content, force)

up/templates/docs_skill/__init__.py

@@ -0,0 +1,49 @@
+"""Docs skill templates."""
+
+from pathlib import Path
+
+
+def create_docs_skill(target_dir: Path, ai_target: str, force: bool = False) -> None:
+    """Create the docs-system skill."""
+    if ai_target in ("claude", "both"):
+        skill_dir = target_dir / ".claude/skills/docs-system"
+    else:
+        skill_dir = target_dir / ".cursor/skills/docs-system"
+
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    _create_skill_md(skill_dir, force)
+
+
+def _write_file(path: Path, content: str, force: bool) -> None:
+    """Write file if it doesn't exist or force is True."""
+    if path.exists() and not force:
+        return
+    path.write_text(content)
+
+
+def _create_skill_md(skill_dir: Path, force: bool) -> None:
+    """Create SKILL.md for docs system."""
+    content = """---
+name: docs
+description: Documentation system with standards
+user-invocable: true
+allowed-tools: Read, Write, Edit, Glob
+---
+
+# Docs Skill
+
+## Commands
+
+- `/docs new [type]` - Create document
+- `/docs status` - Show status
+
+## Types
+
+| Type | Folder |
+|------|--------|
+| feature | features/ |
+| arch | architecture/ |
+| changelog | changelog/ |
+| guide | guides/ |
+"""
+    _write_file(skill_dir / "SKILL.md", content, force)

up/templates/learn/__init__.py

@@ -0,0 +1,93 @@
+"""Learn system templates."""
+
+from pathlib import Path
+
+
+def create_learn_system(target_dir: Path, ai_target: str, force: bool = False) -> None:
+    """Create the learn system structure."""
+    # Determine skill directory based on AI target
+    if ai_target in ("claude", "both"):
+        skill_dir = target_dir / ".claude/skills/learning-system"
+    else:
+        skill_dir = target_dir / ".cursor/skills/learning-system"
+
+    # Create directories
+    dirs = ["research", "insights"]
+    for d in dirs:
+        (skill_dir / d).mkdir(parents=True, exist_ok=True)
+
+    # Create files
+    _create_skill_md(skill_dir, force)
+    _create_sources_json(skill_dir, force)
+    _create_patterns_md(skill_dir, force)
+
+
+def _write_file(path: Path, content: str, force: bool) -> None:
+    """Write file if it doesn't exist or force is True."""
+    if path.exists() and not force:
+        return
+    path.write_text(content)
+
+
+def _create_skill_md(skill_dir: Path, force: bool) -> None:
+    """Create SKILL.md for learn system."""
+    content = """---
+name: learn
+description: Research and create improvement plans
+user-invocable: true
+allowed-tools: Read, Write, Bash, WebFetch, WebSearch
+---
+
+# Learning System
+
+Research best practices and create actionable plans.
+
+## Workflow
+
+```
+RESEARCH → ANALYZE → COMPARE → PLAN
+```
+
+## Commands
+
+- `/learn auto` - Auto-analyze project
+- `/learn research [topic]` - Research topic
+- `/learn plan` - Generate improvement PRD
+
+## Output Files
+
+| File | Purpose |
+|------|---------|
+| `research/*.md` | Research notes |
+| `insights/patterns.md` | Extracted patterns |
+| `prd.json` | Improvement plan |
+"""
+    _write_file(skill_dir / "SKILL.md", content, force)
+
+
+def _create_sources_json(skill_dir: Path, force: bool) -> None:
+    """Create sources.json config."""
+    content = """{
+  "projects": [],
+  "blogs": [],
+  "topics": []
+}
+"""
+    _write_file(skill_dir / "sources.json", content, force)
+
+
+def _create_patterns_md(skill_dir: Path, force: bool) -> None:
+    """Create patterns template."""
+    content = """# Extracted Patterns
+
+**Status**: 🔄 Active
+
+---
+
+## Pattern Template
+
+- **Source**: Project/Blog
+- **Description**: What it does
+- **Applicability**: How to use it
+"""
+    _write_file(skill_dir / "insights/patterns.md", content, force)

up/templates/loop/__init__.py

@@ -0,0 +1,91 @@
+"""Product-loop system templates."""
+
+from pathlib import Path
+
+
+def create_loop_system(target_dir: Path, ai_target: str, force: bool = False) -> None:
+    """Create the product-loop system structure."""
+    # Determine skill directory based on AI target
+    if ai_target in ("claude", "both"):
+        skill_dir = target_dir / ".claude/skills/product-loop"
+    else:
+        skill_dir = target_dir / ".cursor/skills/product-loop"
+
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create files
+    _create_skill_md(skill_dir, force)
+    _create_loop_state(target_dir, force)
+
+
+def _write_file(path: Path, content: str, force: bool) -> None:
+    """Write file if it doesn't exist or force is True."""
+    if path.exists() and not force:
+        return
+    path.write_text(content)
+
+
+def _create_skill_md(skill_dir: Path, force: bool) -> None:
+    """Create SKILL.md for product-loop."""
+    content = """---
+name: product-loop
+description: Resilient development with SESRC principles
+user-invocable: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob, TodoWrite
+---
+
+# Resilient Product Loop
+
+## SESRC Principles
+
+| Principle | Implementation |
+|-----------|----------------|
+| **Stable** | Graceful degradation |
+| **Efficient** | Token budgets |
+| **Safe** | Input validation |
+| **Reliable** | Timeouts, rollback |
+| **Cost-effective** | Early termination |
+
+## Loop
+
+```
+OBSERVE → CHECKPOINT → EXECUTE → VERIFY → COMMIT
+```
+
+## Commands
+
+- `/product-loop` - Start loop
+- `/product-loop resume` - Resume from checkpoint
+- `/product-loop status` - Show state
+- `/product-loop rollback` - Rollback last change
+
+## Circuit Breaker
+
+Max 3 failures before circuit opens.
+
+## State File
+
+`.loop_state.json` tracks progress.
+"""
+    _write_file(skill_dir / "SKILL.md", content, force)
+
+
+def _create_loop_state(target_dir: Path, force: bool) -> None:
+    """Create initial loop state file."""
+    content = """{
+  "version": "1.0",
+  "iteration": 0,
+  "phase": "INIT",
+  "circuit_breaker": {
+    "test": {"failures": 0, "state": "CLOSED"},
+    "build": {"failures": 0, "state": "CLOSED"}
+  },
+  "checkpoints": [],
+  "metrics": {
+    "total_edits": 0,
+    "total_rollbacks": 0,
+    "success_rate": 1.0
+  }
+}
+"""
+    _write_file(target_dir / ".loop_state.json", content, force)

up_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: up-cli
+Version: 0.1.0
+Summary: AI-powered project scaffolding with docs, learn, and product-loop systems
+Project-URL: Homepage, https://github.com/yourusername/up-cli
+Project-URL: Documentation, https://github.com/yourusername/up-cli#readme
+Project-URL: Repository, https://github.com/yourusername/up-cli
+Author-email: Your Name <you@example.com>
+License-Expression: MIT
+Keywords: ai,claude,cli,cursor,productivity,scaffolding
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# up-cli
+
+![img](https://github.com/user-attachments/assets/3339ab7e-0027-4ffb-81c4-79fa5f72c9c8)
+
+An AI-powered CLI tool for scaffolding projects with built-in documentation, learning systems, and product-loop workflows designed for use with Claude Code and Cursor AI.
+
+**Learned from real practice** - Built on insights from 5+ billion tokens of development experience and commercial products. Extracts best practices from chat history, documentation patterns, and proven workflows.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Create new project
+up new my-project
+
+# Or initialize in existing project
+cd existing-project
+up init
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `up new <name>` | Create a new project with full scaffolding |
+| `up new <name> --template <type>` | Create project from specific template |
+| `up init` | Initialize up systems in current directory |
+| `up init --ai claude` | Initialize for Claude Code only |
+| `up init --ai cursor` | Initialize for Cursor AI only |
+| `up init --systems docs,learn` | Initialize specific systems only |
+
+## Usage Examples
+
+### Create a new project
+
+```bash
+# Create a new project with all systems
+up new my-saas-app
+
+# Create with a specific template
+up new my-api --template fastapi
+```
+
+### Initialize in existing project
+
+```bash
+cd my-existing-project
+
+# Full initialization
+up init
+
+# Claude Code focused setup
+up init --ai claude
+
+# Only add docs and learn systems
+up init --systems docs,learn
+```
+
+### Using the Learn System
+
+```bash
+# Auto-analyze your project and generate insights
+/learn auto
+
+# Research a specific topic with web sources
+/learn research "authentication patterns"
+
+# Generate a PRD from your codebase
+/learn plan
+```
+
+### Using the Product Loop
+
+```bash
+# Start autonomous development loop
+./skills/product-loop/start-autonomous.sh
+
+# Run with circuit breaker protection
+./skills/product-loop/ralph_hybrid.sh
+```
+
+## Systems
+
+### 1. Docs System
+
+```
+docs/roadmap/vision/      # Product vision
+docs/roadmap/phases/      # Phase roadmaps
+docs/changelog/           # Progress tracking
+```
+
+### 2. Learn System
+
+- `/learn auto` - Auto-analyze project
+- `/learn research [topic]` - Research topic
+- `/learn plan` - Generate PRD
+
+### 3. Product Loop (SESRC)
+
+- Circuit breaker (max 3 failures)
+- Checkpoint/rollback
+- Health checks
+- Budget limits
+
+## Design Principles & Practices
+
+### AI-First Development
+
+**Design for AI collaboration, not just human readability.**
+
+- **Context-aware scaffolding** - Project structures optimized for AI agents to navigate and understand quickly
+- **Explicit over implicit** - Clear file naming, directory structures, and documentation that AI can parse without ambiguity
+- **Prompt-friendly patterns** - Code and docs written to be easily referenced in AI conversations
+- **Tool integration** - Native support for Claude Code skills and Cursor AI rules
+
+### Documentation-Driven Development
+
+**Documentation is the source of truth, not an afterthought.**
+
+- **Docs-first workflow** - Write documentation before implementation to clarify intent
+- **Living documentation** - Docs evolve with the codebase through automated learning systems
+- **Knowledge extraction** - `/learn` commands analyze patterns and generate insights from real usage
+- **Structured knowledge** - Vision, roadmaps, and changelogs in predictable locations for AI and human consumption
+
+### Product Loop Patterns (SESRC)
+
+**Autonomous development with safety guardrails.**
+
+- **Circuit breaker protection** - Max 3 consecutive failures before stopping to prevent runaway loops
+- **Checkpoint/rollback** - Save state before risky operations, restore on failure
+- **Health checks** - Validate system state between iterations
+- **Budget limits** - Token and time constraints to prevent unbounded execution
+- **Human-in-the-loop** - Critical decisions require explicit approval
+
+### Core Practices
+
+| Practice | Description |
+|----------|-------------|
+| **Incremental delivery** | Ship small, working increments over big-bang releases |
+| **Fail fast, recover faster** | Detect issues early, rollback automatically |
+| **Observable by default** | Logging, metrics, and state visible to both AI and humans |
+| **Convention over configuration** | Sensible defaults that work out of the box |
+
+## Development
+
+```bash
+pip install -e .
+pytest
+```
+
+## License
+
+MIT

up_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+up/__init__.py,sha256=7suBsJ6_nxjrmi-aUlqOniZkgIWUttUoNQ_zT8vza9Q,70
+up/cli.py,sha256=NV7Zn4ep2vEVQsKZWGZqTRSXiefe9sFrN6fsnLLHub8,551
+up/commands/__init__.py,sha256=95wKJUh3jcO5L0kj6UiA5Hanrs1mTnHv_L70PfmMNJ0,23
+up/commands/init.py,sha256=uBLYSict6O2nmywFIfgBbb_Isw8LkB3y5R09XAnrvfQ,1756
+up/commands/new.py,sha256=oYLdf7s0QhI1uZiXhxWdO7S_y8IeVqIdSxsAD4nFPYc,1712
+up/templates/__init__.py,sha256=lTJqsHoYoMAvFMoYttvVJP_zb1w2ELzj04--ckDfFYI,1657
+up/templates/config/__init__.py,sha256=zOUgJWVB_OLPmkKVKyrdGhfV8tpL2m-oGy327Wn8LhE,2219
+up/templates/docs_skill/__init__.py,sha256=0XNjIj5yuwlhqUmIZjjcfQo67J-m_op1RKAVjIn6bho,1201
+up/templates/learn/__init__.py,sha256=8ArFJ0M25gGbPkmdzg3p2LPOqyetefn65NqSC59pBqw,2289
+up/templates/loop/__init__.py,sha256=jC_pAHnMUi34e_RBSu_YFd2oKAXWc3lC_e3M4DPUAPY,2290
+up_cli-0.1.0.dist-info/METADATA,sha256=p2nsFMS50pBc50FzK91k-YbFT7330DHFgaiX-N_x1j0,5545
+up_cli-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+up_cli-0.1.0.dist-info/entry_points.txt,sha256=3xiuYEewTAtul4F7s7mBOBD8s4kUlkdcqNrrMGfLEHA,35
+up_cli-0.1.0.dist-info/RECORD,,

up_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

up_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+up = up.cli:main