jettypod 4.4.118 → 4.4.121

package/crates/jettypod-cli/src/main.rs

@@ -0,0 +1,595 @@
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use clap::{Parser, Subcommand};
+
+mod commands;
+
+use commands::CommandContext;
+
+/// Find the project root by walking up from cwd looking for `.jettypod/`.
+fn find_project_root() -> Result<PathBuf> {
+    let mut dir = std::env::current_dir()?;
+    loop {
+        if dir.join(".jettypod").exists() {
+            return Ok(dir);
+        }
+        if !dir.pop() {
+            bail!("Not in a JettyPod project (no .jettypod/ found). Run `jettypod init` first.");
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// CLI structure
+// ---------------------------------------------------------------------------
+
+#[derive(Parser)]
+#[command(name = "jettypod", version, about = "JettyPod workflow CLI")]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Initialize a new JettyPod project in the current directory.
+    Init {
+        /// Project name (defaults to directory name).
+        name: Option<String>,
+    },
+
+    /// Set the project description.
+    Describe {
+        /// Description text.
+        #[arg(num_args = 1.., required = true)]
+        description: Vec<String>,
+    },
+
+    /// Regenerate CLAUDE.md from config.
+    Generate,
+
+    /// Manage work items (create, start, stop, merge, etc).
+    Work {
+        #[command(subcommand)]
+        action: WorkAction,
+    },
+
+    /// Show the project backlog.
+    Backlog {
+        /// Expand specific IDs (comma-separated).
+        #[arg(long)]
+        expand: Option<String>,
+
+        /// Expand all items.
+        #[arg(long)]
+        expand_all: bool,
+    },
+
+    /// View and manage architectural decisions.
+    Decisions {
+        /// Show all decisions.
+        #[arg(long)]
+        all: bool,
+
+        /// Show project-level decisions only.
+        #[arg(long)]
+        project: bool,
+
+        /// Show all epic decisions.
+        #[arg(long)]
+        epics: bool,
+
+        /// Show decisions for a specific epic.
+        #[arg(long)]
+        epic: Option<i64>,
+
+        /// Show decisions file.
+        #[arg(long)]
+        view: bool,
+    },
+
+    /// Manage project settings.
+    Project {
+        #[command(subcommand)]
+        action: ProjectAction,
+    },
+
+    /// Emit a UI gate marker (for dashboard narrated mode).
+    Ui {
+        #[command(subcommand)]
+        action: UiAction,
+    },
+
+    /// Check what files are affected by changes.
+    Impact {
+        /// File path to check.
+        file: String,
+    },
+
+    /// Manage workflow state.
+    Workflow {
+        #[command(subcommand)]
+        action: WorkflowAction,
+    },
+}
+
+// ---------------------------------------------------------------------------
+// Work subcommands
+// ---------------------------------------------------------------------------
+
+#[derive(Subcommand)]
+enum WorkAction {
+    /// Create a new work item.
+    Create {
+        /// Create from JSON file.
+        #[arg(long)]
+        from: Option<String>,
+
+        /// Work item type (epic, feature, chore, bug).
+        #[arg(value_name = "TYPE")]
+        item_type: Option<String>,
+
+        /// Title.
+        title: Option<String>,
+
+        /// Description.
+        description: Option<String>,
+
+        /// Parent work item ID.
+        #[arg(long)]
+        parent: Option<i64>,
+
+        /// Initial mode (speed, stable, production).
+        #[arg(long)]
+        mode: Option<String>,
+
+        /// Mark as needing discovery.
+        #[arg(long)]
+        needs_discovery: bool,
+    },
+
+    /// Start working on an item (creates worktree).
+    Start {
+        /// Work item ID.
+        id: i64,
+    },
+
+    /// Stop working on the current item.
+    Stop {
+        /// Status to set (in_progress, blocked, done, skip).
+        status: Option<String>,
+    },
+
+    /// Update a work item's status.
+    Status {
+        /// Work item ID.
+        id: i64,
+        /// New status.
+        status: String,
+    },
+
+    /// Show the current work item.
+    Current,
+
+    /// Show details of a work item.
+    Show {
+        /// Work item ID.
+        id: i64,
+    },
+
+    /// Update a work item's description.
+    Describe {
+        /// Work item ID.
+        id: i64,
+        /// Description text.
+        #[arg(num_args = 1.., required = true)]
+        description: Vec<String>,
+    },
+
+    /// Get children of a work item.
+    Children {
+        /// Parent work item ID.
+        id: i64,
+    },
+
+    /// Merge a worktree back to main.
+    Merge {
+        /// Work item ID (auto-detects if in worktree).
+        id: Option<i64>,
+        /// Force release merge lock.
+        #[arg(long)]
+        release_lock: bool,
+    },
+
+    /// Clean up a worktree after merge.
+    Cleanup {
+        /// Work item ID (batch cleanup if omitted).
+        id: Option<i64>,
+        /// Force cleanup even if merge not complete.
+        #[arg(long)]
+        force: bool,
+        /// Preview what would be cleaned.
+        #[arg(long)]
+        dry_run: bool,
+    },
+
+    /// Set a work item's mode.
+    SetMode {
+        /// Work item ID.
+        id: i64,
+        /// Mode (discovery, speed, stable, production).
+        mode: String,
+    },
+
+    /// Elevate a work item to a higher mode.
+    Elevate {
+        /// Work item ID.
+        id: i64,
+        /// Target mode (stable, production).
+        mode: String,
+    },
+
+    /// Manage test worktrees.
+    Tests {
+        #[command(subcommand)]
+        action: Option<TestAction>,
+
+        /// Feature ID (for shorthand `work tests <id>`).
+        #[arg(value_name = "FEATURE_ID")]
+        id: Option<i64>,
+    },
+
+    /// Manage prototype worktrees.
+    Prototype {
+        #[command(subcommand)]
+        action: PrototypeAction,
+    },
+
+    /// Record an epic architectural decision.
+    EpicImplement {
+        /// Epic ID.
+        id: i64,
+        /// Decision aspect/category.
+        #[arg(long)]
+        aspect: String,
+        /// Chosen approach.
+        #[arg(long)]
+        decision: String,
+        /// Rationale for the choice.
+        #[arg(long)]
+        rationale: String,
+        /// Prototype file paths (comma-separated).
+        #[arg(long)]
+        prototypes: Option<String>,
+    },
+
+    /// Set QA checklist steps for a work item (JSON).
+    SetQaSteps {
+        /// Work item ID.
+        id: i64,
+        /// Read QA steps JSON from file.
+        #[arg(long)]
+        from: Option<String>,
+        /// QA steps JSON string (alternative to --from).
+        steps: Option<String>,
+    },
+
+    /// Transition a feature from discovery to implementation.
+    Implement {
+        /// Feature ID.
+        id: i64,
+        /// Prototype file paths (comma-separated).
+        #[arg(long)]
+        prototypes: Option<String>,
+        /// Winning prototype path.
+        #[arg(long)]
+        winner: Option<String>,
+    },
+}
+
+#[derive(Subcommand)]
+enum TestAction {
+    /// Start a test worktree.
+    Start {
+        /// Feature ID.
+        id: i64,
+    },
+    /// Merge test worktree.
+    Merge {
+        /// Feature ID.
+        id: i64,
+    },
+}
+
+#[derive(Subcommand)]
+enum PrototypeAction {
+    /// Start a prototype worktree.
+    Start {
+        /// Feature ID.
+        id: i64,
+        /// Approach name.
+        approach: String,
+    },
+    /// Merge prototype worktree.
+    Merge {
+        /// Feature ID.
+        id: i64,
+    },
+}
+
+// ---------------------------------------------------------------------------
+// Project subcommands
+// ---------------------------------------------------------------------------
+
+#[derive(Subcommand)]
+enum ProjectAction {
+    /// Show current project state.
+    State,
+    /// Show project info.
+    Info,
+    /// Transition project to external state.
+    External,
+    /// Manage project discovery.
+    Discover {
+        #[command(subcommand)]
+        action: DiscoverAction,
+    },
+    /// Manage project prototypes.
+    Prototype {
+        #[command(subcommand)]
+        action: ProjectPrototypeAction,
+    },
+}
+
+#[derive(Subcommand)]
+enum DiscoverAction {
+    /// Start discovery phase.
+    Start,
+    /// Complete discovery phase.
+    Complete {
+        /// Winning approach path.
+        #[arg(long)]
+        winner: String,
+        /// Rationale for choice.
+        #[arg(long)]
+        rationale: String,
+        /// Prototype file paths (comma-separated).
+        #[arg(long)]
+        prototypes: Option<String>,
+    },
+}
+
+#[derive(Subcommand)]
+enum ProjectPrototypeAction {
+    /// Start a project prototype.
+    Start {
+        /// Approach name.
+        approach: String,
+    },
+    /// Merge project prototype.
+    Merge,
+}
+
+// ---------------------------------------------------------------------------
+// UI subcommands
+// ---------------------------------------------------------------------------
+
+#[derive(Subcommand)]
+enum UiAction {
+    /// Emit a gate marker.
+    Gate {
+        /// Gate type.
+        #[arg(value_name = "TYPE")]
+        gate_type: String,
+        /// Optional JSON data.
+        #[arg(long)]
+        data: Option<String>,
+    },
+}
+
+// ---------------------------------------------------------------------------
+// Workflow subcommands
+// ---------------------------------------------------------------------------
+
+#[derive(Subcommand)]
+enum WorkflowAction {
+    /// Start a workflow execution.
+    Start {
+        /// Skill name.
+        skill: String,
+        /// Work item ID.
+        id: i64,
+    },
+    /// Complete a workflow execution.
+    Complete {
+        /// Skill name.
+        skill: String,
+        /// Work item ID.
+        id: i64,
+    },
+    /// Record a workflow checkpoint.
+    Checkpoint {
+        /// Work item ID.
+        id: i64,
+        /// Step number.
+        #[arg(long)]
+        step: i64,
+    },
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        None => {
+            // No subcommand: check if project exists, init or launch dashboard
+            match find_project_root() {
+                Ok(root) => {
+                    let ctx = CommandContext::new(&root)?;
+                    commands::launch_dashboard(&ctx).await
+                }
+                Err(_) => {
+                    eprintln!("Not in a JettyPod project. Run `jettypod init` to get started.");
+                    Ok(())
+                }
+            }
+        }
+        Some(cmd) => dispatch(cmd).await,
+    }
+}
+
+async fn dispatch(cmd: Commands) -> Result<()> {
+    match cmd {
+        Commands::Init { name } => commands::init(name),
+
+        Commands::Describe { description } => {
+            let root = find_project_root()?;
+            commands::describe(&root, &description.join(" "))
+        }
+
+        Commands::Generate => {
+            let root = find_project_root()?;
+            commands::generate(&root)
+        }
+
+        Commands::Work { action } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            dispatch_work(&ctx, action)
+        }
+
+        Commands::Backlog {
+            expand,
+            expand_all,
+        } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            commands::backlog(&ctx, expand.as_deref(), expand_all)
+        }
+
+        Commands::Decisions {
+            all,
+            project,
+            epics,
+            epic,
+            view,
+        } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            commands::decisions(&ctx, all, project, epics, epic, view)
+        }
+
+        Commands::Project { action } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            dispatch_project(&ctx, action)
+        }
+
+        Commands::Ui { action } => dispatch_ui(action),
+
+        Commands::Impact { file } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            commands::impact(&ctx, &file)
+        }
+
+        Commands::Workflow { action } => {
+            let root = find_project_root()?;
+            let ctx = CommandContext::new(&root)?;
+            dispatch_workflow(&ctx, action)
+        }
+    }
+}
+
+fn dispatch_work(ctx: &CommandContext, action: WorkAction) -> Result<()> {
+    match action {
+        WorkAction::Create {
+            from,
+            item_type,
+            title,
+            description,
+            parent,
+            mode,
+            needs_discovery,
+        } => commands::work_create(ctx, from, item_type, title, description, parent, mode, needs_discovery),
+
+        WorkAction::Start { id } => commands::work_start(ctx, id),
+        WorkAction::Stop { status } => commands::work_stop(ctx, status),
+        WorkAction::Status { id, status } => commands::work_status(ctx, id, &status),
+        WorkAction::Current => commands::work_current(ctx),
+        WorkAction::Show { id } => commands::work_show(ctx, id),
+        WorkAction::Describe { id, description } => {
+            commands::work_describe(ctx, id, &description.join(" "))
+        }
+        WorkAction::Children { id } => commands::work_children(ctx, id),
+        WorkAction::Merge { id, release_lock } => commands::work_merge(ctx, id, release_lock),
+        WorkAction::Cleanup {
+            id,
+            force,
+            dry_run,
+        } => commands::work_cleanup(ctx, id, force, dry_run),
+        WorkAction::SetMode { id, mode } => commands::work_set_mode(ctx, id, &mode),
+        WorkAction::Elevate { id, mode } => commands::work_elevate(ctx, id, &mode),
+        WorkAction::Tests { action, id } => commands::work_tests(ctx, action, id),
+        WorkAction::Prototype { action } => commands::work_prototype(ctx, action),
+        WorkAction::EpicImplement {
+            id,
+            aspect,
+            decision,
+            rationale,
+            prototypes,
+        } => commands::work_epic_implement(ctx, id, &aspect, &decision, &rationale, prototypes),
+        WorkAction::SetQaSteps { id, from, steps } => commands::work_set_qa_steps(ctx, id, from, steps),
+        WorkAction::Implement {
+            id,
+            prototypes,
+            winner,
+        } => commands::work_implement(ctx, id, prototypes, winner),
+    }
+}
+
+fn dispatch_project(ctx: &CommandContext, action: ProjectAction) -> Result<()> {
+    match action {
+        ProjectAction::State => commands::project_state(ctx),
+        ProjectAction::Info => commands::project_info(ctx),
+        ProjectAction::External => commands::project_external(ctx),
+        ProjectAction::Discover { action } => match action {
+            DiscoverAction::Start => commands::project_discover_start(ctx),
+            DiscoverAction::Complete {
+                winner,
+                rationale,
+                prototypes,
+            } => commands::project_discover_complete(ctx, &winner, &rationale, prototypes),
+        },
+        ProjectAction::Prototype { action } => match action {
+            ProjectPrototypeAction::Start { approach } => {
+                commands::project_prototype_start(ctx, &approach)
+            }
+            ProjectPrototypeAction::Merge => commands::project_prototype_merge(ctx),
+        },
+    }
+}
+
+fn dispatch_ui(action: UiAction) -> Result<()> {
+    match action {
+        UiAction::Gate { gate_type, data } => {
+            let json = data.unwrap_or_else(|| "{}".to_string());
+            println!("[GATE:{gate_type}]{json}[/GATE]");
+            Ok(())
+        }
+    }
+}
+
+fn dispatch_workflow(ctx: &CommandContext, action: WorkflowAction) -> Result<()> {
+    match action {
+        WorkflowAction::Start { skill, id } => commands::workflow_start(ctx, &skill, id),
+        WorkflowAction::Complete { skill, id } => commands::workflow_complete(ctx, &skill, id),
+        WorkflowAction::Checkpoint { id, step } => commands::workflow_checkpoint(ctx, id, step),
+    }
+}

package/crates/jettypod-core/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "jettypod-core"
+version = "0.1.0"
+edition = "2021"
+description = "JettyPod core business logic — database, work tracking, git, config, auth"
+
+[dependencies]
+rusqlite = { version = "0.31", features = ["bundled", "hooks"] }
+refinery = { version = "0.8", features = ["rusqlite"] }
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "net", "time", "process", "io-util"] }
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+chrono = { workspace = true }
+log = { workspace = true }
+jsonwebtoken = "9"
+url = { workspace = true }
+dirs = "6"
+strum = { version = "0.26", features = ["derive"] }
+tokio-tungstenite = "0.24"
+futures-util = "0.3"
+notify = "6"
+
+[dev-dependencies]
+tempfile = "3"