i-self 0.4.3

Personal developer-companion CLI: scans your repos, indexes code semantically, watches your activity, and moves AI-agent sessions between tools (Claude Code, Aider, Goose, OpenAI Codex CLI, Continue.dev, OpenCode).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

#![allow(dead_code)]

use anyhow::Result;
use std::path::Path;
use tracing::info;
use serde::{Serialize, Deserialize};

pub mod code_analyzer;
pub mod pattern_extractor;
pub mod git_analyzer;

pub use code_analyzer::CodeAnalyzer;
pub use pattern_extractor::PatternExtractor;
pub use git_analyzer::GitAnalyzer;

/// Main analyzer that coordinates code analysis
pub struct Analyzer {
    code_analyzer: CodeAnalyzer,
    pattern_extractor: PatternExtractor,
    git_analyzer: GitAnalyzer,
}

impl Analyzer {
    pub fn new() -> Self {
        Self {
            code_analyzer: CodeAnalyzer::new(),
            pattern_extractor: PatternExtractor::new(),
            git_analyzer: GitAnalyzer::new(),
        }
    }

    /// Analyze a local project directory
    pub async fn analyze_project(&self, path: &Path) -> Result<ProjectAnalysis> {
        info!("Analyzing project at: {}", path.display());
        
        let git_info = self.git_analyzer.analyze(path).await?;
        let code_stats = self.code_analyzer.analyze_directory(path).await?;
        let patterns = self.pattern_extractor.extract_patterns(path, &code_stats).await?;
        
        Ok(ProjectAnalysis {
            path: path.to_path_buf(),
            git_info,
            code_stats,
            patterns,
        })
    }

    /// Analyze multiple projects in parallel
    pub async fn analyze_projects(&self, paths: &[&Path]) -> Result<Vec<ProjectAnalysis>> {
        use futures::future::join_all;
        
        let futures = paths.iter().map(|path| self.analyze_project(path));
        let results = join_all(futures).await;
        
        results.into_iter().collect::<Result<Vec<_>>>()
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectAnalysis {
    pub path: std::path::PathBuf,
    pub git_info: GitInfo,
    pub code_stats: CodeStatistics,
    pub patterns: Vec<DetectedPattern>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GitInfo {
    pub is_git_repo: bool,
    pub current_branch: Option<String>,
    pub recent_commits: Vec<CommitInfo>,
    pub remote_url: Option<String>,
    pub total_commits: i64,
    pub contributors: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommitInfo {
    pub hash: String,
    pub message: String,
    pub author: String,
    pub date: chrono::DateTime<chrono::Utc>,
    pub files_changed: Vec<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CodeStatistics {
    pub total_files: usize,
    pub total_lines: usize,
    pub languages: std::collections::HashMap<String, LanguageStats>,
    pub file_types: std::collections::HashMap<String, usize>,
    pub average_file_size: usize,
    pub largest_files: Vec<(String, usize)>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LanguageStats {
    pub file_count: usize,
    pub total_lines: usize,
    pub code_lines: usize,
    pub comment_lines: usize,
    pub blank_lines: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectedPattern {
    pub pattern_type: String,
    pub confidence: f64,
    pub evidence: String,
    pub files: Vec<String>,
}