chronicle-devkit 0.1.0__py3-none-any.whl

chronicle/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

chronicle/ai/base.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+class AIProvider(ABC):
+    @abstractmethod
+    def generate(self,prompt:str) -> str:
+        """Generate a response from the AI model."""
+        raise NotImplementedError

chronicle/ai/factory.py

@@ -0,0 +1,23 @@
+from chronicle.ai.base import AIProvider
+from chronicle.ai.openai import OpenAIProvider
+from chronicle.ai.google_ai import GenAIProvider
+
+def create_provider(
+    provider: str,
+    model:str,
+    api_key:str
+) -> AIProvider:
+    if provider == "openai":
+        return OpenAIProvider(
+            api_key=api_key,
+            model=model,
+        )
+    elif provider == "gemini":
+        return GenAIProvider(
+            api_key=api_key,
+            model=model,
+        )
+        
+    raise ValueError(
+        f"Unsupported AI provider: {provider}"
+    )

chronicle/ai/google_ai.py

@@ -0,0 +1,14 @@
+from google import genai
+from chronicle.ai.base import AIProvider
+
+class GenAIProvider(AIProvider):
+    def __init__(self,model:str,api_key:str) -> None:
+        self.client = genai.Client(api_key=api_key)
+        self.model = model
+        
+    def generate(self, prompt: str) -> str:
+        response = self.client.models.generate_content(
+            model=self.model,
+            contents = prompt,
+        )
+        return response.text if response.text else "Error: Model did not respond"

chronicle/ai/openai.py

@@ -0,0 +1,14 @@
+from openai import OpenAI
+from chronicle.ai.base import AIProvider
+
+class OpenAIProvider(AIProvider):
+    def __init__(self,api_key:str,model:str) -> None:
+        self.client = OpenAI(api_key=api_key)
+        self.model = model
+        
+    def generate(self, prompt: str) -> str:
+        response = self.client.responses.create(
+            model=self.model,
+            input=prompt,
+        )
+        return response.output_text

chronicle/analysis/analyzers/base.py

@@ -0,0 +1,15 @@
+from abc import ABC,abstractmethod
+from pathlib import Path
+from chronicle.storage.models import Observation,Findings
+from chronicle.analysis.context import AnalysisContext
+
+class BaseAnalyzer(ABC):
+    """Base class for all chronicle analyzers."""
+        
+    def __init__(self,project_root:Path) -> None:
+        self.project_root = project_root
+        
+    @abstractmethod
+    def analyze(self, context:AnalysisContext) -> list[Findings]:
+        """Analyze the project and return findings."""
+        pass

chronicle/analysis/analyzers/django_migrations.py

@@ -0,0 +1,74 @@
+from chronicle.analysis.analyzers.base import BaseAnalyzer
+from chronicle.storage.models import Findings
+import typer
+from chronicle.storage.observations import Observation
+from chronicle.analysis.context import AnalysisContext
+
+class DjangoMigrationAnalyzer(BaseAnalyzer):
+
+    def analyze(
+        self,
+        context: AnalysisContext
+    ) -> list[Findings]:
+
+        findings = []
+
+        for observation in context.observations:
+
+            if observation.source != "django":
+                continue
+
+            if observation.type != "migration":
+                continue
+
+            operations = observation.data.get(
+                "operations",
+                []
+            )
+
+            for operation in operations:
+
+                operation_name = operation.get(
+                    "operation"
+                )
+
+                if operation_name == "RemoveField":
+                    typer.echo(
+                        f"Generating finding: "
+                        f"observation={observation.id}, "
+                        f"data={operation}"
+                    )
+                    findings.append(
+                        Findings(
+                            analyzer="django-migrations",
+                            severity="warning",
+                            title="Field removed",
+                            message=(
+                                "A database field is being "
+                                "removed by this migration."
+                            ),
+                            observation_id= observation.id, #type: ignore
+                            data=operation,
+                        )
+                    )
+                if operation_name == "AddField":
+                    typer.echo(
+                        f"Generating finding: "
+                        f"observation={observation.id}, "
+                        f"data={operation}"
+                    )
+                    findings.append(
+                        Findings(
+                            analyzer="django-migrations",
+                            severity="info",
+                            title="Field added",
+                            message=(
+                                "A database field is being "
+                                "added by this migration."
+                            ),
+                            observation_id= observation.id, #type: ignore
+                            data=operation,
+                        )
+                    )
+
+        return findings

chronicle/analysis/analyzers/git.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from chronicle.storage.models import Observation,Findings
+from .base import BaseAnalyzer
+from chronicle.analysis.context import AnalysisContext
+
+class GitAnalyzer(BaseAnalyzer):
+    def __init__(self, project_root: Path) -> None:
+        super().__init__(project_root)
+        
+    def analyze(self,context:AnalysisContext) -> list[Findings]:
+        findings = []
+        for observation in context.observations:
+            if observation.type != "commit":
+                continue
+            if observation.source != "git":
+                continue
+
+            message = observation.data.get("message","Not given")
+            author = observation.data.get("author","unknown")
+            parsed_message = author + ":" + message
+            changes = observation.data.get("changes",[])
+            
+            for change in changes:
+                file_status = change.get("status")
+                if file_status == "A":
+                    findings.append(
+                        Findings(
+                            analyzer="git_analyzer",
+                            severity="info",
+                            title="New File created",
+                            message=parsed_message,
+                            observation_id=observation.id, #type: ignore
+                            data=change
+                    ))
+                    
+        return findings

chronicle/analysis/context.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass,field
+from chronicle.storage.observations import Observation
+
+@dataclass
+class AnalysisContext:
+    observations: list[Observation]
+    state: dict[str,str | None] = field(
+            default_factory=dict
+        )
+        
+    def get_state(self,analyzer:str,key:str) -> str |None:
+            return self.state.get(f"{analyzer}.{key}")

chronicle/analysis/engine.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from chronicle.analysis.context import AnalysisContext
+
+
+from chronicle.analysis.analyzers.base import BaseAnalyzer
+from chronicle.storage.models import Observation,Findings
+
+class AnalyzeEngine:
+    def __init__(self, analyzers:list[BaseAnalyzer]) -> None:
+        self.analyzers = analyzers
+        
+    def analyze(self,context:AnalysisContext) -> list[Findings]:
+        findings = []
+        for analyzer in self.analyzers:
+            analyzer_findings = analyzer.analyze(context)
+            findings.extend(analyzer_findings)
+            
+        return findings

chronicle/cli/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

chronicle/cli/commands/analyze.py

@@ -0,0 +1,73 @@
+import typer
+from chronicle.analysis.engine import AnalyzeEngine
+from chronicle.analysis.analyzers.git import GitAnalyzer
+from chronicle.analysis.analyzers.django_migrations import DjangoMigrationAnalyzer
+from chronicle.config.loader import get_chronicle_directory
+from chronicle.project.discovery import find_project_root
+from chronicle.storage.database import connect
+from chronicle.storage.observations import ObservationRepo
+from chronicle.storage.findings import FindingsRepo
+from chronicle.analysis.context import AnalysisContext
+from chronicle.storage.analysis_state import AnalysisStateRepo
+
+def analyze():
+    """Analyzes all observations done by chronicle."""
+
+    project_root = find_project_root()
+    if project_root:
+        db_path = (get_chronicle_directory(project_root) / "chronicle.db")
+        conn = connect(db_path)
+        observations = ObservationRepo(conn).list_all()
+        analysis_state = AnalysisStateRepo(conn)
+        last_obs_id = analysis_state.get(
+            "last_observation_id",
+            "analysis"
+        )
+        
+        if last_obs_id is not None:
+            observations = [
+                observation for observation in observations if observation.id > int(last_obs_id) #type: ignore
+            ]
+            
+        context = AnalysisContext(
+            observations=observations,
+            state={
+                "analysis.last_observation_id":last_obs_id,
+            }
+        )
+        
+        repo = FindingsRepo(conn)
+        analyzers = [
+            GitAnalyzer(project_root),
+            DjangoMigrationAnalyzer(project_root),
+        ]
+        engine = AnalyzeEngine(analyzers) #type: ignore
+        findings = engine.analyze(context)
+        
+        finding_count = 0
+        
+        with conn:
+            for finding in findings:
+                if repo.save(finding):
+                    finding_count +=1
+         
+            if observations:
+                newest_obs_id = max(
+                    observation.id for observation in observations #type: ignore
+                ) 
+                
+                analysis_state.set(
+                    "last_observation_id",
+                    "analysis",
+                    str(newest_obs_id)
+                )       
+        typer.echo(f"Analyzed and stored {finding_count} findings.")
+        typer.echo(
+            f"Last analyzed observation: {last_obs_id}"
+        )
+
+        typer.echo(
+            f"Observations being analyzed: "
+            f"{[observation.id for observation in observations]}"
+        )
+            

chronicle/cli/commands/config.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+import typer
+from chronicle.project.discovery import find_project_root
+from chronicle.config.loader import *
+from chronicle.config.manager import *
+from chronicle.config.credentials import has_api_key,set_api_key
+
+config_app = typer.Typer(
+    help="Manage Chronicle configuration."
+)
+
+@config_app.command("set")
+def set_config(
+    key: str = typer.Argument(...),
+    value: str = typer.Argument(...),
+):
+    """Set a Chronicle config value."""
+    project_root = find_project_root()
+    if project_root:
+        config_path = get_config_path(project_root)
+        config = load_config(config_path)
+        if key == "provider":   
+            update_ai_config(
+                config_path,
+                provider=value,
+            )
+        elif key == "model":
+            update_ai_config(
+                config_path,
+                model=value,
+            )
+        elif key == "api_key":
+            if config["ai"]["provider"] != "":
+                set_api_key(provider=config["ai"]["provider"],api_key=value)
+        else:
+            typer.echo(f"Unknown config key: {key}")
+            typer.echo("Available key: provider, model, api_key")
+            raise typer.Exit(1)
+        
+        typer.echo(
+            f"Updated {key} = {value}"
+        )
+    else:
+        typer.echo("Chronicle not initialized.")
+        raise typer.Exit(1)
+            
+@config_app.callback(invoke_without_command=True)
+def config(ctx: typer.Context):
+    """View Chronicle configurations."""
+    if ctx.invoked_subcommand is not None:
+        return
+    
+    project_root = find_project_root()
+    if project_root:
+        config_path = get_config_path(project_root)
+        configuration = load_config(config_path)
+        if not configuration:
+            typer.echo("Chronicle config is empty.")
+            return
+        ai = configuration.get("ai",{})
+        
+        provider = ai.get("provider","")
+        model = ai.get('model', '')
+        
+        if provider:
+            api_status = (
+                "configured" if has_api_key(provider) else "not configured"
+            )
+        else:
+            api_status = "not configured"
+        
+        typer.echo("Chronicle Configuration")
+        typer.echo("=======================")
+        typer.echo(f"Provider : {provider}")
+        typer.echo(f"Model    : {model}")
+        typer.echo(f"API Key    : {api_status}")
+    else:
+        typer.echo("Chronicle not initialized.")
+        

chronicle/cli/commands/init.py

@@ -0,0 +1,47 @@
+import typer
+from chronicle.project.discovery import find_project_root
+from chronicle.project.initializer import initialize_chronicle,setup_ai_config
+
+def init():
+    """Initialize chronicle in a project"""
+    
+    project_root = find_project_root()
+    
+    if project_root is None:
+        typer.echo(f"Error: No .git files found in the current working directory",err=True)
+        raise typer.Exit(code=1)
+    
+    config_path,created = initialize_chronicle(project_root)
+    
+    if created:
+        typer.echo()
+        typer.echo("   ╔══════════════════════════════════════╗")
+        typer.echo("   ║          C H R O N I C L E           ║")
+        typer.echo("   ╚══════════════════════════════════════╝")
+        typer.echo()
+
+        typer.echo("   ✦ Initializing Chronicle...")
+        typer.echo()
+
+        typer.echo("   ✓ Project detected")
+        typer.echo("   ✓ Chronicle directory created")
+        typer.echo("   ✓ Local database initialized")
+        typer.echo("   ✓ Initialized NLTK tokenizer")
+        typer.echo()
+        
+        choice = typer.prompt("   Configure AI now?[Y/n] ").lower()
+        if choice == "y":
+            setup_ai_config(config_path=config_path)
+            typer.echo("   ✓ AI successfully configured.")
+            typer.echo()
+        else:
+            typer.echo("   AI not configured.")
+            typer.echo("   Use chronicle set command to configure AI.")
+            typer.echo()
+
+        typer.echo("   Chronicle is ready.")
+        typer.echo()
+        typer.echo("   Run `chronicle scan` to begin collecting observations.")
+        typer.echo()
+    else:
+        typer.echo(f"Chronicle already initiated at: {project_root}")

chronicle/cli/commands/interpret.py

@@ -0,0 +1,48 @@
+import typer
+from chronicle.project.discovery import find_project_root
+from chronicle.config.loader import get_chronicle_directory, load_config, get_config_path
+from chronicle.interpretation.context_builder import *
+from chronicle.storage.database import connect
+from chronicle.storage.findings import FindingsRepo
+from chronicle.storage.observations import ObservationRepo
+from chronicle.interpretation.interpreter import Interpreter
+from chronicle.ai.factory import GenAIProvider
+from chronicle.config.credentials import get_api_key
+
+def interpret(query: str = typer.Option(...,"--question","-q",help="Question to ask the project history.")):
+    """Interpret Chronicle's project history using AI."""
+    project_root = find_project_root()
+    if project_root is None:
+        typer.echo("Chronicle project not found.")
+        raise typer.Exit(1)
+    
+    db_path = (get_chronicle_directory(project_root) / "chronicle.db")
+    
+    conn = connect(db_path)
+    
+    findings_repo = FindingsRepo(conn)
+    observation_repo = ObservationRepo(conn)
+    
+    findings = findings_repo.list_all()
+    observations = observation_repo.list_all()
+    
+    context = build_context(
+        question=query,
+        findings=findings,
+        observations=observations)
+    
+    config_path = get_config_path(project_root)
+    config = load_config(config_path)
+    ai = config.get("ai",{})
+    model = ai.get("model")
+    provider_name = ai.get("provider")
+    api_key = get_api_key(provider=provider_name)
+    if not api_key:
+        typer.echo(f"Couldn't find an api key for {provider_name} provider")
+        raise typer.Exit(1)
+    provider = GenAIProvider(model=model,api_key=api_key)
+    
+    interpreter = Interpreter(provider=provider)
+    response = interpreter.interpret(context)
+    
+    typer.echo(response)

chronicle/cli/commands/scan.py

@@ -0,0 +1,87 @@
+import typer
+from chronicle.project.discovery import find_project_root
+from chronicle.scanning.scanners.git import GitScanner
+from chronicle.scanning.scanners.django_migrations import DjangoMigrationScanner
+from chronicle.scanning.engine import ScanEngine
+from chronicle.config.loader import get_chronicle_directory
+from chronicle.storage.database import connect
+from chronicle.storage.observations import ObservationRepo
+from chronicle.storage.scan_state import ScanStateRepo
+from chronicle.scanning.context import ScanContext
+
+def scan():
+    """Scan the project and collect observation"""
+    project_root = find_project_root()
+    if project_root is None:
+        typer.echo("Error: could not find git repo.",err=True)
+        raise typer.Exit(code=1)
+    
+    db_path = (get_chronicle_directory(project_root) / "chronicle.db")
+    connection = connect(database_path=db_path)
+    scan_state = ScanStateRepo(connection)
+    repo = ObservationRepo(connection)
+    last_commit = scan_state.get(
+        "last_commit",
+        "git",
+    )
+    last_migration = scan_state.get(
+        "last_migration",
+        "django_migrations",
+    )
+    git_context = ScanContext(
+        state={
+            "git.last_commit":last_commit,
+        }
+    )
+    django_context = ScanContext(
+        state={
+            "django_migrations.last_migration":last_migration,
+        }
+    )
+    contexts = [git_context,django_context]
+    
+    scanners = [
+        GitScanner(project_root),
+        DjangoMigrationScanner(project_root)
+    ]
+    
+    engine = ScanEngine(
+        project_root=project_root,
+        scanners=scanners, #type: ignore
+    )
+    
+    observations = engine.scan(contexts=contexts)
+    
+    created_count = 0
+    
+    git_observations = [ observation for observation in observations if observation.source == "git"]
+    
+    django_observations = [ observation for observation in observations if observation.source == "django"]
+    
+    with connection:
+        for observation in observations:
+            if repo.save(observation=observation):
+                created_count+=1
+    
+        if git_observations:
+            newest_commit = git_observations[0].external_id
+            scan_state.set(
+                "last_commit",
+                "git",
+                newest_commit
+            )
+        if django_observations:
+            newest_migration = django_observations[-1].external_id
+            scan_state.set(
+                "last_migration",
+                "django_migrations",
+                newest_migration
+            )
+        
+    connection.close()
+    
+    if created_count > 0:
+        typer.echo(f"Collected {len(observations)} observation(s).")
+        typer.echo(f"Stored {created_count} new observation(s)")
+    else:
+        typer.echo(f"All observation(s) already stored.")