Add dummy provider pipeline

Author: ProfRandom92

PROJEKT.md

@@ -22,7 +22,7 @@ CompText CLI is an experimental terminal context client for building determinist
 | **Phase 0** | Repo Genesis & Bootstrap | Scaffold Rust project, basic commands (`help`, `doctor`, `providers list`, `version`), verify CI | **COMPLETE** |
 | **Phase 1** | CLI Shell Hardening | Hardening argument parsing, input handling, and errors for the base shell commands | **COMPLETE** |
 | **Phase 2** | Context Pack Contract | Implement `ctxt context inspect`, `ctxt context pack --task "..."`, and `ctxt ask --dry-run "..."` | **COMPLETE** |
-| **Phase 3** | Provider Adapter Layer | Define provider interface and Dummy offline test provider | *PLANNED* |
+| **Phase 3** | Provider Adapter Layer | Define provider interface and Dummy offline test provider | **COMPLETE** |
 | **Phase 4** | Ollama Local Adapter | Support local Ollama integrations with explicit network boundaries | *PLANNED* |
 | **Phase 5** | Proposal Apply Gate | Implement proposal files, approval checks, and validation flow | *PLANNED* |
 

reports/phase_3_status.md

@@ -0,0 +1,49 @@
+# CompText CLI — Phase 3 Status Report
+
+This report documents the implementation and verification details of Phase 3 (Dummy Provider integration).
+
+## 1. Objectives & Scope
+- **Goal**: Implement the offline dummy provider pipeline to support request/response dry-run execution without requiring network or live API keys.
+- **Trigger Command**: `ctxt ask --provider dummy "<PROMPT>"`
+- **Deliverables**:
+  - Normalized `Provider` trait (interface).
+  - Concrete `DummyProvider` implementation producing deterministic responses.
+  - Integration of provider execution workflow into `src/cli.rs`.
+  - Offline tests ensuring proper request wrapping and serialization.
+
+## 2. Implementation Summary
+- **Provider Interface (`src/provider.rs`)**:
+  Defines `Provider` with:
+  - `fn name(&self) -> &str`
+  - `fn execute(&self, request: &ModelRequest) -> Result<ModelResponse, String>`
+- **Dummy Adapter (`src/provider.rs`)**:
+  - Analyzes the `ModelRequest` content (system prompt) to determine the number of files packed.
+  - Outputs a deterministic markdown/text answer referencing the user prompt and context pack size.
+- **CLI Command Matching**:
+  - Enhanced command parsing in `src/cli.rs` to allow optional parameter parsing (e.g. `--provider <name>` and `--dry-run`).
+  - Serializes and stores final LLM answers into `.comptext/model_response.latest.json` when run without `--dry-run`.
+  - Re-uses existing context pack contract outputs.
+
+## 3. Local Verification Results
+- `cargo fmt --all --check` (Passed)
+- `cargo check` (Passed)
+- `cargo test` (Passed 14 test cases total, including `ask_dummy_provider_succeeds`)
+- `cargo clippy -- -D warnings` (Passed)
+
+Run Verification Command:
+```bash
+cargo run --bin ctxt -- ask --provider dummy "How do I test this repo?"
+```
+Stdout:
+```text
+Response from dummy provider:
+Mock LLM response from CompText Dummy Provider.
+Received prompt: "How do I test this repo?"
+Workspace context analyzed successfully: 45 files included.
+Dummy status: offline-test-provider ok.
+```
+
+## 4. Safety & Claims Hygiene
+- Network access remained completely denied.
+- No environment variables or credentials were read or dumped.
+- No production readiness or official compliance assertions were made.

src/cli.rs

@@ -9,8 +9,14 @@ enum Command {
     Doctor,
     ProvidersList,
     ContextInspect,
-    ContextPack { task: String },
-    Ask { dry_run: bool, prompt: String },
+    ContextPack {
+        task: String,
+    },
+    Ask {
+        provider: Option<String>,
+        dry_run: bool,
+        prompt: String,
+    },
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -87,7 +93,11 @@ where
                 1
             }
         },
-        Ok(Command::Ask { dry_run, prompt }) => match handle_ask(dry_run, &prompt) {
+        Ok(Command::Ask {
+            provider,
+            dry_run,
+            prompt,
+        }) => match handle_ask(provider.as_deref(), dry_run, &prompt) {
             Ok(_) => 0,
             Err(e) => {
                 eprintln!("error: {e}");
@@ -189,22 +199,53 @@ fn parse(argv: &[String]) -> Result<Command, String> {
         "ask" => {
             if argv.len() < 3 {
                 return Err(
-                    "missing arguments for 'ask'. Usage: ctxt ask --dry-run \"<prompt>\""
+                    "missing arguments for 'ask'. Usage: ctxt ask --dry-run \"<prompt>\" or ctxt ask --provider <provider> \"<prompt>\""
                         .to_string(),
                 );
             }
-            if argv[1] != "--dry-run" {
-                return Err(format!(
-                    "unexpected option '{}' for 'ask'. Expected '--dry-run'",
-                    argv[1]
-                ));
+
+            let mut provider = None;
+            let mut dry_run = false;
+            let mut prompt = String::new();
+
+            let mut i = 1;
+            while i < argv.len() {
+                match argv[i].as_str() {
+                    "--dry-run" => {
+                        dry_run = true;
+                        i += 1;
+                    }
+                    "--provider" => {
+                        if i + 1 >= argv.len() {
+                            return Err("missing provider name after --provider".to_string());
+                        }
+                        provider = Some(argv[i + 1].clone());
+                        i += 2;
+                    }
+                    other => {
+                        if other.starts_with('-') {
+                            return Err(format!("unsupported option '{other}' for 'ask'"));
+                        }
+                        if !prompt.is_empty() {
+                            return Err(format!("unexpected argument '{other}' for 'ask'"));
+                        }
+                        prompt = other.to_string();
+                        i += 1;
+                    }
+                }
             }
-            let prompt = argv[2].clone();
-            if argv.len() > 3 {
-                return Err(format!("unexpected argument '{}' for 'ask'", argv[3]));
+
+            if prompt.is_empty() {
+                return Err("missing prompt for 'ask'".to_string());
+            }
+
+            if !dry_run && provider.is_none() {
+                return Err("must specify either --dry-run or --provider <provider>".to_string());
             }
+
             Ok(Command::Ask {
-                dry_run: true,
+                provider,
+                dry_run,
                 prompt,
             })
         }
@@ -410,11 +451,7 @@ fn handle_context_pack(task: &str) -> Result<(), String> {
     Ok(())
 }
 
-fn handle_ask(dry_run: bool, prompt: &str) -> Result<(), String> {
-    if !dry_run {
-        return Err("Only dry-run is supported. Use --dry-run flag.".to_string());
-    }
-
+fn handle_ask(provider: Option<&str>, dry_run: bool, prompt: &str) -> Result<(), String> {
     let cp = build_context_pack(prompt)?;
     std::fs::create_dir_all(".comptext")
         .map_err(|e| format!("failed to create .comptext directory: {e}"))?;
@@ -430,7 +467,7 @@ fn handle_ask(dry_run: bool, prompt: &str) -> Result<(), String> {
         cp.rendered_context
     );
     let request = ModelRequest {
-        provider: "dummy".to_string(),
+        provider: provider.unwrap_or("dummy").to_string(),
         model: "dummy-model".to_string(),
         messages: vec![
             Message {
@@ -450,10 +487,32 @@ fn handle_ask(dry_run: bool, prompt: &str) -> Result<(), String> {
     std::fs::write(".comptext/model_request.latest.json", req_json)
         .map_err(|e| format!("failed to write model request: {e}"))?;
 
-    println!("Dry-run successful.");
-    println!("Context Pack: .comptext/context_pack.latest.json");
-    println!("Model Request: .comptext/model_request.latest.json");
-    Ok(())
+    if dry_run {
+        println!("Dry-run successful.");
+        println!("Context Pack: .comptext/context_pack.latest.json");
+        println!("Model Request: .comptext/model_request.latest.json");
+        return Ok(());
+    }
+
+    let p_name = provider.ok_or_else(|| "provider is required for live execution".to_string())?;
+    match p_name {
+        "dummy" => {
+            use crate::provider::{DummyProvider, Provider};
+            let prov = DummyProvider;
+            let response = prov.execute(&request)?;
+
+            let resp_json = serde_json::to_string_pretty(&response)
+                .map_err(|e| format!("failed to serialize model response: {e}"))?;
+
+            std::fs::write(".comptext/model_response.latest.json", resp_json)
+                .map_err(|e| format!("failed to write model response: {e}"))?;
+
+            println!("Response from {} provider:", prov.name());
+            println!("{}", response.content);
+            Ok(())
+        }
+        other => Err(format!("unsupported provider '{other}'")),
+    }
 }
 
 #[cfg(test)]
@@ -519,12 +578,30 @@ mod tests {
         assert_eq!(
             parse(&s(&["ask", "--dry-run", "How do I test this repo?"])),
             Ok(Command::Ask {
+                provider: None,
                 dry_run: true,
                 prompt: "How do I test this repo?".to_string()
             })
         );
     }
 
+    #[test]
+    fn parses_ask_provider() {
+        assert_eq!(
+            parse(&s(&[
+                "ask",
+                "--provider",
+                "dummy",
+                "How do I test this repo?"
+            ])),
+            Ok(Command::Ask {
+                provider: Some("dummy".to_string()),
+                dry_run: false,
+                prompt: "How do I test this repo?".to_string()
+            })
+        );
+    }
+
     #[test]
     fn rejects_unknown_command() {
         assert!(parse(&s(&["unknown"])).is_err());

src/main.rs

@@ -1,4 +1,5 @@
 mod cli;
+mod provider;
 
 fn main() {
     let code = cli::run(std::env::args().skip(1));

src/provider.rs

@@ -0,0 +1,52 @@
+use crate::cli::ModelRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct ModelResponse {
+    pub provider: String,
+    pub model: String,
+    pub content: String,
+}
+
+pub trait Provider {
+    fn name(&self) -> &str;
+    fn execute(&self, request: &ModelRequest) -> Result<ModelResponse, String>;
+}
+
+pub struct DummyProvider;
+
+impl Provider for DummyProvider {
+    fn name(&self) -> &str {
+        "dummy"
+    }
+
+    fn execute(&self, request: &ModelRequest) -> Result<ModelResponse, String> {
+        // Count how many files are formatted in the system message context
+        let file_count = if let Some(sys_msg) = request.messages.iter().find(|m| m.role == "system")
+        {
+            sys_msg.content.matches("=== FILE: ").count()
+        } else {
+            0
+        };
+
+        let user_prompt = request
+            .messages
+            .iter()
+            .find(|m| m.role == "user")
+            .map(|m| m.content.as_str())
+            .unwrap_or("");
+
+        let content = format!(
+            "Mock LLM response from CompText Dummy Provider.\n\
+             Received prompt: \"{user_prompt}\"\n\
+             Workspace context analyzed successfully: {file_count} files included.\n\
+             Dummy status: offline-test-provider ok."
+        );
+
+        Ok(ModelResponse {
+            provider: "dummy".to_string(),
+            model: "dummy-model".to_string(),
+            content,
+        })
+    }
+}

tests/cli_smoke.rs

@@ -30,3 +30,17 @@ fn providers_include_dummy_and_ollama_variants() {
     assert!(stdout.contains("ollama-local"));
     assert!(stdout.contains("ollama-cloud-direct"));
 }
+
+#[test]
+fn ask_dummy_provider_succeeds() {
+    let stdout = run(&["ask", "--provider", "dummy", "How do I test this repo?"]);
+    assert!(stdout.contains("Response from dummy provider:"));
+    assert!(stdout.contains("Mock LLM response from CompText Dummy Provider."));
+    assert!(stdout.contains("Received prompt: \"How do I test this repo?\""));
+
+    // Verify response file was written
+    let response_path = std::path::Path::new(".comptext/model_response.latest.json");
+    assert!(response_path.exists());
+    let response_content = std::fs::read_to_string(response_path).unwrap();
+    assert!(response_content.contains("\"provider\": \"dummy\""));
+}