feat: add core/git/ai/plugin/telemetry crates, dynamic version from git tag in CI

Author: Swofty-Developments

.github/workflows/release.yml

@@ -55,6 +55,20 @@ jobs:
             libsoup-3.0-dev \
             libjavascriptcoregtk-4.1-dev
 
+      - name: Set version from tag
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          echo "Setting version to $VERSION"
+          # Update workspace Cargo.toml
+          sed -i.bak "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
+          # Update each crate's Cargo.toml
+          for f in crates/*/Cargo.toml; do
+            sed -i.bak "s/^version = \".*\"/version = \"$VERSION\"/" "$f" 2>/dev/null || true
+          done
+          rm -f Cargo.toml.bak crates/*/Cargo.toml.bak
+
       - name: Install frontend dependencies
         working-directory: crates/tauri-app/frontend
         run: npm ci --ignore-scripts || npm install

Cargo.lock

@@ -1,6 +1,21 @@
 [workspace]
 resolver = "2"
-members = ["crates/tauri-app", "crates/session", "crates/persistence"]
+members = [
+    "crates/tauri-app",
+    "crates/session",
+    "crates/persistence",
+    "crates/core",
+    "crates/git",
+    "crates/ai",
+    "crates/plugin",
+    "crates/telemetry",
+]
+# Only build app crates by default — library crates are standalone
+default-members = [
+    "crates/tauri-app",
+    "crates/session",
+    "crates/persistence",
+]
 
 [workspace.package]
 version = "0.1.0"

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "codeforge-ai"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "AI provider abstraction and message types for CodeForge"
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+uuid = { workspace = true }
+chrono = { workspace = true }
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }

crates/ai/Cargo.toml

@@ -0,0 +1,114 @@
+//! Context window tracking and compaction strategies.
+
+use serde::{Deserialize, Serialize};
+
+/// Tracks token usage within the AI context window.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ContextWindow {
+    /// Maximum tokens the model supports.
+    pub capacity: u64,
+    /// Tokens used by the system prompt.
+    pub system_tokens: u64,
+    /// Tokens used by conversation messages.
+    pub message_tokens: u64,
+    /// Tokens used by tool definitions.
+    pub tool_tokens: u64,
+    /// Tokens reserved for the model's response.
+    pub response_reserve: u64,
+}
+
+impl ContextWindow {
+    /// Create a new context window with the given capacity.
+    pub fn new(capacity: u64) -> Self {
+        Self {
+            capacity,
+            ..Default::default()
+        }
+    }
+
+    /// Returns the total tokens currently used.
+    pub fn used(&self) -> u64 {
+        self.system_tokens + self.message_tokens + self.tool_tokens
+    }
+
+    /// Returns the number of tokens available for new messages.
+    pub fn available(&self) -> u64 {
+        self.capacity
+            .saturating_sub(self.used())
+            .saturating_sub(self.response_reserve)
+    }
+
+    /// Returns the usage as a fraction (0.0 to 1.0).
+    pub fn usage_fraction(&self) -> f64 {
+        if self.capacity == 0 {
+            return 0.0;
+        }
+        self.used() as f64 / self.capacity as f64
+    }
+
+    /// Returns `true` if context compaction should be triggered.
+    ///
+    /// Defaults to triggering at 90% usage.
+    pub fn needs_compaction(&self) -> bool {
+        self.usage_fraction() > 0.9
+    }
+
+    /// Returns `true` if the context window is effectively full
+    /// (less than 5% remaining after response reserve).
+    pub fn is_full(&self) -> bool {
+        self.available() < (self.capacity / 20)
+    }
+}
+
+impl std::fmt::Display for ContextWindow {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let pct = (self.usage_fraction() * 100.0) as u32;
+        write!(
+            f,
+            "{}/{} tokens ({}% used, {} available)",
+            self.used(),
+            self.capacity,
+            pct,
+            self.available()
+        )
+    }
+}
+
+/// Trait for implementing context compaction strategies.
+pub trait ContextManager {
+    /// The error type for compaction operations.
+    type Error: std::error::Error;
+
+    /// Compact the context by summarizing or removing older messages.
+    ///
+    /// Returns the number of tokens freed.
+    fn compact(&self, window: &ContextWindow) -> Result<CompactionResult, Self::Error>;
+
+    /// Estimate the token count for a given text.
+    fn estimate_tokens(&self, text: &str) -> u64;
+}
+
+/// The result of a context compaction operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompactionResult {
+    /// Number of tokens freed by compaction.
+    pub tokens_freed: u64,
+    /// Number of messages removed or summarized.
+    pub messages_affected: usize,
+    /// The compaction strategy that was used.
+    pub strategy: CompactionStrategy,
+}
+
+/// Available strategies for compacting the context window.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CompactionStrategy {
+    /// Remove the oldest messages.
+    TruncateOldest,
+    /// Summarize older messages into a condensed form.
+    Summarize,
+    /// Remove tool result content but keep tool use records.
+    StripToolResults,
+    /// Remove thinking blocks from assistant messages.
+    StripThinking,
+}

crates/ai/src/context.rs

@@ -0,0 +1,140 @@
+//! Token usage tracking and cost calculation.
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// A report of token usage for a single API call.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct UsageReport {
+    /// Number of input tokens consumed.
+    pub input_tokens: u64,
+    /// Number of output tokens generated.
+    pub output_tokens: u64,
+    /// Number of tokens used for caching (cache reads).
+    pub cache_read_tokens: u64,
+    /// Number of tokens written to cache.
+    pub cache_write_tokens: u64,
+    /// The model that was used.
+    pub model: Option<String>,
+    /// Timestamp of this usage event.
+    pub timestamp: Option<DateTime<Utc>>,
+}
+
+impl UsageReport {
+    /// Returns the total token count (input + output).
+    pub fn total_tokens(&self) -> u64 {
+        self.input_tokens + self.output_tokens
+    }
+}
+
+impl fmt::Display for UsageReport {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "in: {} | out: {} | total: {}",
+            self.input_tokens,
+            self.output_tokens,
+            self.total_tokens()
+        )?;
+        if self.cache_read_tokens > 0 {
+            write!(f, " | cache read: {}", self.cache_read_tokens)?;
+        }
+        Ok(())
+    }
+}
+
+/// Accumulates usage across multiple API calls within a session.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CostTracker {
+    /// All usage reports accumulated so far.
+    reports: Vec<UsageReport>,
+    /// Running total of input tokens.
+    total_input: u64,
+    /// Running total of output tokens.
+    total_output: u64,
+    /// Running total of cache read tokens.
+    total_cache_read: u64,
+    /// Running total of cache write tokens.
+    total_cache_write: u64,
+    /// Number of API calls made.
+    api_calls: u64,
+}
+
+impl CostTracker {
+    /// Create a new empty cost tracker.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Record a new usage report.
+    pub fn record(&mut self, report: UsageReport) {
+        self.total_input += report.input_tokens;
+        self.total_output += report.output_tokens;
+        self.total_cache_read += report.cache_read_tokens;
+        self.total_cache_write += report.cache_write_tokens;
+        self.api_calls += 1;
+        self.reports.push(report);
+    }
+
+    /// Returns the total input tokens across all API calls.
+    pub fn total_input_tokens(&self) -> u64 {
+        self.total_input
+    }
+
+    /// Returns the total output tokens across all API calls.
+    pub fn total_output_tokens(&self) -> u64 {
+        self.total_output
+    }
+
+    /// Returns the grand total of all tokens.
+    pub fn total_tokens(&self) -> u64 {
+        self.total_input + self.total_output
+    }
+
+    /// Returns the number of API calls tracked.
+    pub fn api_call_count(&self) -> u64 {
+        self.api_calls
+    }
+
+    /// Returns the average tokens per API call.
+    pub fn avg_tokens_per_call(&self) -> f64 {
+        if self.api_calls == 0 {
+            return 0.0;
+        }
+        self.total_tokens() as f64 / self.api_calls as f64
+    }
+
+    /// Estimate the cost in USD based on model pricing.
+    ///
+    /// Uses approximate pricing: input $3/MTok, output $15/MTok for Sonnet-class models.
+    pub fn estimated_cost_usd(&self) -> f64 {
+        let input_cost = self.total_input as f64 * 3.0 / 1_000_000.0;
+        let output_cost = self.total_output as f64 * 15.0 / 1_000_000.0;
+        let cache_read_cost = self.total_cache_read as f64 * 0.30 / 1_000_000.0;
+        let cache_write_cost = self.total_cache_write as f64 * 3.75 / 1_000_000.0;
+        input_cost + output_cost + cache_read_cost + cache_write_cost
+    }
+
+    /// Returns a reference to all recorded usage reports.
+    pub fn reports(&self) -> &[UsageReport] {
+        &self.reports
+    }
+
+    /// Reset the tracker, clearing all accumulated data.
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+}
+
+impl fmt::Display for CostTracker {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} calls | {} total tokens | ~${:.4}",
+            self.api_calls,
+            self.total_tokens(),
+            self.estimated_cost_usd()
+        )
+    }
+}