Refactor test files for improved organization and readability

- Adjusted imports in integration tests to ensure correct module loading.
- Cleaned up whitespace in various test files for consistency.
- Reorganized the order of module imports in protocol tests for clarity.
- Enhanced readability in tools tests by formatting multi-line structures.
- Ensured consistent error message assertions in search and create tests.
- Streamlined test assertions for better clarity and maintainability.

Author: Marvin Zhang

.github/workflows/ci.yml

@@ -7,6 +7,50 @@ on:
     branches: [main]
 
 jobs:
+  # Node.js/TypeScript build and test
+  node:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: '10.26.0'
+          run_install: false
+      
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
+      
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+      
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+      
+      - name: Build all packages
+        run: pnpm build
+      
+      - name: Run typecheck
+        run: pnpm typecheck
+      
+      - name: Run tests
+        run: pnpm test
+
   # Rust build and test
   rust:
     runs-on: ubuntu-latest

.github/workflows/copilot-setup-steps.yml

@@ -31,6 +31,18 @@ jobs:
         with:
           node-version: "20"
 
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: "10.26.0"
+          run_install: false
+
+      - name: Install JavaScript dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build lean-spec CLI (TypeScript)
+        run: pnpm --filter lean-spec run build
+
       - name: Set up Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
 

rust/leanspec-cli/src/commands/agent.rs

@@ -3,10 +3,10 @@
 //! Dispatch specs to AI coding agents for automated implementation.
 
 use colored::Colorize;
+use leanspec_core::SpecLoader;
 use std::error::Error;
-use std::process::{Command, Stdio};
 use std::fs;
-use leanspec_core::SpecLoader;
+use std::process::{Command, Stdio};
 
 /// Supported AI agents
 const SUPPORTED_AGENTS: &[&str] = &["claude", "copilot", "aider", "gemini", "cursor", "continue"];
@@ -36,7 +36,12 @@ pub fn run(
 
 fn show_help() {
     println!();
-    println!("{}", "LeanSpec Agent - Dispatch specs to AI coding agents".cyan().bold());
+    println!(
+        "{}",
+        "LeanSpec Agent - Dispatch specs to AI coding agents"
+            .cyan()
+            .bold()
+    );
     println!();
     println!("{}", "Usage:".bold());
     println!("  lean-spec agent run <spec> [--agent <type>]  Dispatch spec to AI agent");
@@ -68,61 +73,66 @@ fn run_agent(
     dry_run: bool,
 ) -> Result<(), Box<dyn Error>> {
     let spec_ids = specs.ok_or("At least one spec is required for 'run' action")?;
-    
+
     if spec_ids.is_empty() {
         return Err("At least one spec is required".into());
     }
-    
+
     let agent_name = agent.unwrap_or_else(|| "claude".to_string());
-    
+
     // Validate agent
     if !SUPPORTED_AGENTS.contains(&agent_name.as_str()) {
         return Err(format!(
             "Unknown agent: {}. Supported: {}",
             agent_name,
             SUPPORTED_AGENTS.join(", ")
-        ).into());
+        )
+        .into());
     }
-    
+
     // Check if agent is available
     let agent_command = get_agent_command(&agent_name);
     if !is_command_available(&agent_command) && !dry_run {
         return Err(format!(
             "Agent not found: {}. Make sure {} is installed and in your PATH.",
             agent_name, agent_command
-        ).into());
+        )
+        .into());
     }
-    
+
     println!();
-    println!("{}", format!("🤖 Dispatching to {} agent", agent_name.cyan()).green());
+    println!(
+        "{}",
+        format!("🤖 Dispatching to {} agent", agent_name.cyan()).green()
+    );
     println!();
-    
+
     // Load specs
     let loader = SpecLoader::new(specs_dir);
     let all_specs = loader.load_all()?;
-    
+
     // Find matching specs
     let mut found_specs = Vec::new();
     for spec_id in &spec_ids {
         let matching: Vec<_> = all_specs
             .iter()
             .filter(|s| s.path.contains(spec_id) || s.name().contains(spec_id))
             .collect();
-        
+
         if matching.is_empty() {
             return Err(format!("Spec not found: {}", spec_id).into());
         }
-        
+
         found_specs.extend(matching);
     }
-    
+
     println!("{}", "Specs to process:".bold());
     for spec in &found_specs {
         let status_icon = spec.frontmatter.status_emoji();
         println!("  • {} {}", spec.name(), status_icon);
     }
     println!();
-    
+
     if dry_run {
         println!("{}", "Dry run mode - no actions will be taken".yellow());
         println!();
@@ -139,41 +149,44 @@ fn run_agent(
         }
         return Ok(());
     }
-    
+
     // Process each spec
     for spec in &found_specs {
         println!("{}", format!("Processing: {}", spec.name()).bold());
-        
+
         // Update status to in-progress (if not disabled)
         if !no_status_update {
             println!("  {} Updated status to in-progress", "✓".green());
         }
-        
+
         // Create worktree for parallel development
         if parallel {
-            println!("  {} Creating worktree (not implemented in Rust CLI yet)", "⚠".yellow());
+            println!(
+                "  {} Creating worktree (not implemented in Rust CLI yet)",
+                "⚠".yellow()
+            );
         }
-        
+
         // Load spec content
         let readme_path = spec.file_path.clone();
         let content = fs::read_to_string(&readme_path).unwrap_or_default();
-        
+
         // Launch agent
         println!("  {} Launching {}...", "→".cyan(), agent_name);
-        
+
         let result = launch_agent(&agent_name, spec.name(), &content);
-        
+
         match result {
             Ok(_) => println!("  {} Agent session started", "✓".green()),
             Err(e) => println!("  {} Failed to launch agent: {}", "✗".red(), e),
         }
-        
+
         println!();
     }
-    
+
     println!("{}", "✨ Agent dispatch complete".green());
     println!("Use {} to check progress", "lean-spec agent status".cyan());
-    
+
     Ok(())
 }
 
@@ -185,7 +198,7 @@ fn list_agents(output_format: &str) -> Result<(), Box<dyn Error>> {
         available: bool,
         agent_type: String,
     }
-    
+
     let agents: Vec<AgentInfo> = SUPPORTED_AGENTS
         .iter()
         .map(|&name| {
@@ -198,17 +211,17 @@ fn list_agents(output_format: &str) -> Result<(), Box<dyn Error>> {
             }
         })
         .collect();
-    
+
     if output_format == "json" {
         println!("{}", serde_json::to_string_pretty(&agents)?);
         return Ok(());
     }
-    
+
     println!();
     println!("{}", "=== Available AI Agents ===".green().bold());
     println!();
     println!("{}", "CLI-based (local):".bold());
-    
+
     for agent in &agents {
         let status = if agent.available {
             "✓".green()
@@ -217,52 +230,63 @@ fn list_agents(output_format: &str) -> Result<(), Box<dyn Error>> {
         };
         println!("  {} {} ({})", status, agent.name, agent.command.dimmed());
     }
-    
+
     println!();
     println!("Set default: {}", "lean-spec agent config <agent>".cyan());
-    println!("Run agent:   {}", "lean-spec agent run <spec> --agent <agent>".cyan());
+    println!(
+        "Run agent:   {}",
+        "lean-spec agent run <spec> --agent <agent>".cyan()
+    );
     println!();
-    
+
     Ok(())
 }
 
 fn show_status(specs: Option<Vec<String>>, output_format: &str) -> Result<(), Box<dyn Error>> {
     // In a real implementation, this would track active sessions
     // For now, just report that there are no active sessions
-    
+
     if output_format == "json" {
         println!("{{}}");
         return Ok(());
     }
-    
+
     println!();
-    
+
     if let Some(spec_ids) = specs {
         for spec_id in spec_ids {
-            println!("{}", format!("No active session for spec: {}", spec_id).yellow());
+            println!(
+                "{}",
+                format!("No active session for spec: {}", spec_id).yellow()
+            );
         }
     } else {
         println!("{}", "No active agent sessions".dimmed());
     }
-    
+
     println!();
-    
+
     Ok(())
 }
 
 fn configure_default_agent(agent: Option<String>) -> Result<(), Box<dyn Error>> {
     let agent_name = agent.ok_or("Agent name required for 'config' action")?;
-    
+
     if !SUPPORTED_AGENTS.contains(&agent_name.as_str()) {
         return Err(format!(
             "Unknown agent: {}. Supported: {}",
             agent_name,
             SUPPORTED_AGENTS.join(", ")
-        ).into());
+        )
+        .into());
     }
-    
-    println!("{} Default agent set to: {}", "✓".green(), agent_name.cyan());
-    
+
+    println!(
+        "{} Default agent set to: {}",
+        "✓".green(),
+        agent_name.cyan()
+    );
+
     Ok(())
 }
 
@@ -290,7 +314,7 @@ fn is_command_available(command: &str) -> bool {
             .map(|s| s.success())
             .unwrap_or(false)
     }
-    
+
     #[cfg(not(target_os = "windows"))]
     {
         Command::new("which")
@@ -305,20 +329,23 @@ fn is_command_available(command: &str) -> bool {
 
 fn launch_agent(agent: &str, _spec_name: &str, content: &str) -> Result<(), Box<dyn Error>> {
     let command = get_agent_command(agent);
-    
+
     // Build context template
     let context = format!(
         "Implement the following LeanSpec specification:\n\n---\n{}\n---\n\n\
          Please follow the spec's design, plan, and test sections. \
          Update the spec status to 'complete' when done.",
         content.chars().take(2000).collect::<String>()
     );
-    
+
     // Launch agent based on type
     match agent {
         "claude" => {
             println!("  {} Context prepared for Claude", "✓".green());
-            println!("  {} Copy the spec content and paste into Claude", "ℹ".cyan());
+            println!(
+                "  {} Copy the spec content and paste into Claude",
+                "ℹ".cyan()
+            );
         }
         "aider" => {
             // Aider takes --message flag
@@ -333,9 +360,13 @@ fn launch_agent(agent: &str, _spec_name: &str, content: &str) -> Result<(), Box<
                 .spawn()?;
         }
         _ => {
-            println!("  {} Launch {} manually with the spec content", "ℹ".cyan(), agent);
+            println!(
+                "  {} Launch {} manually with the spec content",
+                "ℹ".cyan(),
+                agent
+            );
         }
     }
-    
+
     Ok(())
 }