code-explore 0.1.0__tar.gz → 0.3.0__tar.gz

code_explore-0.3.0/.github/workflows/pages.yml

@@ -0,0 +1,44 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'docs/**'
+      - 'install.*'
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Prepare site
+        run: |
+          mkdir -p _site
+          cp docs/index.html _site/index.html
+          cp docs/CNAME _site/CNAME
+          cp install.sh _site/install.sh
+          cp install.ps1 _site/install.ps1
+          cp install.cmd _site/install.cmd
+
+      - uses: actions/upload-pages-artifact@v3
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

{code_explore-0.1.0 → code_explore-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-explore
-Version: 0.1.0
+Version: 0.3.0
 Summary: Developer knowledge base CLI — scan, index, and search your programming projects
 Project-URL: Homepage, https://github.com/aipioneers/code-explore
 Project-URL: Repository, https://github.com/aipioneers/code-explore
@@ -24,7 +24,9 @@ Requires-Dist: httpx>=0.24.0
 Requires-Dist: lancedb>=0.4.0
 Requires-Dist: pyarrow>=14.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=13.0.0
+Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: typer>=0.9.0
 Provides-Extra: api
 Requires-Dist: fastapi>=0.100.0; extra == 'api'

{code_explore-0.1.0 → code_explore-0.3.0}/code_explore/api/main.py

@@ -1,18 +1,20 @@
 """FastAPI REST API for Code Explore."""
 
-import asyncio
 import hashlib
+from collections import Counter
 from datetime import datetime
 from pathlib import Path
 
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
 from code_explore.database import init_db, save_project, get_project, get_all_projects, get_project_count
-from code_explore.models import Project, ProjectSource, ProjectStatus
+from code_explore.models import Project, ProjectSource, ProjectStatus, SearchFacets
+from code_explore.search.filters import apply_filters, filter_projects, compute_facets
 
-app = FastAPI(title="Code Explore", version="0.1.0", description="Developer knowledge base API")
+app = FastAPI(title="Code Explore", version="0.3.0", description="Developer knowledge base API")
 
 app.add_middleware(
     CORSMiddleware,
@@ -43,36 +45,38 @@ class StatsResponse(BaseModel):
     languages: dict[str, int]
     frameworks: dict[str, int]
     patterns: dict[str, int]
+    ai_tags: dict[str, int]
     total_files: int
     total_lines: int
     statuses: dict[str, int]
 
 
+class TagInfo(BaseModel):
+    value: str
+    category: str
+    count: int
+
+
+class TagsResponse(BaseModel):
+    tags: list[TagInfo]
+    total_tags: int
+    categories: dict[str, int]
+
+
 @app.get("/api/projects", response_model=list[Project])
 async def list_projects(
     language: str | None = Query(None, description="Filter by primary language"),
     framework: str | None = Query(None, description="Filter by framework"),
     source: str | None = Query(None, description="Filter by source (local, github, gitlab)"),
+    tag: str | None = Query(None, description="Filter by AI tag"),
 ):
     projects = get_all_projects()
 
-    if language:
-        lang_lower = language.lower()
-        projects = [
-            p for p in projects
-            if p.primary_language and p.primary_language.lower() == lang_lower
-        ]
-
-    if framework:
-        fw_lower = framework.lower()
-        projects = [
-            p for p in projects
-            if any(f.lower() == fw_lower for f in p.frameworks)
-        ]
-
     if source:
         projects = [p for p in projects if p.source.value == source]
 
+    projects = filter_projects(projects, language=language, framework=framework, tag=tag)
+
     return projects
 
 
@@ -89,6 +93,10 @@ async def search_projects(
     q: str = Query(..., description="Search query"),
     mode: str = Query("hybrid", description="Search mode: fulltext, semantic, or hybrid"),
     limit: int = Query(20, ge=1, le=100, description="Maximum results"),
+    language: str | None = Query(None, description="Filter by primary language"),
+    framework: str | None = Query(None, description="Filter by framework"),
+    pattern: str | None = Query(None, description="Filter by pattern"),
+    tag: str | None = Query(None, description="Filter by AI tag"),
 ):
     if mode == "fulltext":
         from code_explore.search.fulltext import search as fulltext_search
@@ -100,6 +108,9 @@ async def search_projects(
         from code_explore.search.hybrid import search as hybrid_search
         results = hybrid_search(q, limit=limit)
 
+    # Apply post-filters
+    results = apply_filters(results, language=language, framework=framework, pattern=pattern, tag=tag)
+
     return [
         {
             "project": r.project.model_dump(),
@@ -111,6 +122,61 @@ async def search_projects(
     ]
 
 
+@app.get("/api/facets", response_model=SearchFacets)
+async def get_facets(
+    q: str | None = Query(None, description="Search query to scope facets"),
+    language: str | None = Query(None, description="Active language filter"),
+    framework: str | None = Query(None, description="Active framework filter"),
+    pattern: str | None = Query(None, description="Active pattern filter"),
+    tag: str | None = Query(None, description="Active tag filter"),
+):
+    if q:
+        # Get search results first, then compute facets from those
+        from code_explore.search.hybrid import search as hybrid_search
+        results = hybrid_search(q, limit=500)
+        projects = [r.project for r in results]
+    else:
+        projects = get_all_projects()
+
+    # Apply active filters to scope facets
+    projects = filter_projects(projects, language=language, framework=framework, pattern=pattern, tag=tag)
+
+    return compute_facets(projects)
+
+
+@app.get("/api/tags", response_model=TagsResponse)
+async def get_tags(
+    category: str | None = Query(None, description="Filter by category: domain, technology-role, maturity"),
+):
+    projects = get_all_projects()
+
+    tag_counts: Counter[str] = Counter()
+    tag_categories: dict[str, str] = {}
+
+    for p in projects:
+        for t in p.ai_tags:
+            cat = t.category.value if hasattr(t.category, "value") else str(t.category)
+            if category and cat != category:
+                continue
+            tag_counts[t.value] += 1
+            tag_categories[t.value] = cat
+
+    tags_list = [
+        TagInfo(value=value, category=tag_categories[value], count=count)
+        for value, count in tag_counts.most_common()
+    ]
+
+    category_counts: Counter[str] = Counter()
+    for t in tags_list:
+        category_counts[t.category] += 1
+
+    return TagsResponse(
+        tags=tags_list,
+        total_tags=len(tags_list),
+        categories=dict(category_counts),
+    )
+
+
 @app.get("/api/stats", response_model=StatsResponse)
 async def get_stats():
     projects = get_all_projects()
@@ -118,6 +184,7 @@ async def get_stats():
     languages: dict[str, int] = {}
     frameworks: dict[str, int] = {}
     patterns: dict[str, int] = {}
+    ai_tags: dict[str, int] = {}
     statuses: dict[str, int] = {}
     total_files = 0
     total_lines = 0
@@ -129,6 +196,8 @@ async def get_stats():
             frameworks[fw] = frameworks.get(fw, 0) + 1
         for pat in p.patterns:
             patterns[pat.name] = patterns.get(pat.name, 0) + 1
+        for t in p.ai_tags:
+            ai_tags[t.value] = ai_tags.get(t.value, 0) + 1
         statuses[p.status.value] = statuses.get(p.status.value, 0) + 1
         total_files += p.quality.total_files
         total_lines += p.quality.total_lines
@@ -138,6 +207,7 @@ async def get_stats():
         languages=dict(sorted(languages.items(), key=lambda x: x[1], reverse=True)),
         frameworks=dict(sorted(frameworks.items(), key=lambda x: x[1], reverse=True)),
         patterns=dict(sorted(patterns.items(), key=lambda x: x[1], reverse=True)),
+        ai_tags=dict(sorted(ai_tags.items(), key=lambda x: x[1], reverse=True)),
         total_files=total_files,
         total_lines=total_lines,
         statuses=statuses,
@@ -195,3 +265,9 @@ async def trigger_scan(request: ScanRequest):
         results.append(project)
 
     return ScanResponse(scanned=len(results), projects=results)
+
+
+# Mount static files for the dashboard (must be after API routes)
+_static_dir = Path(__file__).parent.parent / "static"
+if _static_dir.is_dir():
+    app.mount("/", StaticFiles(directory=str(_static_dir), html=True), name="static")

code_explore-0.3.0/code_explore/cli/config_cmd.py

@@ -0,0 +1,96 @@
+"""CLI commands for configuration management."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from code_explore.config import (
+    _get_config_dir,
+    get_config_path,
+    get_resolved_settings,
+    reset_config,
+    write_default_config,
+    _discover_config_file,
+)
+
+config_app = typer.Typer(
+    name="config",
+    help="Manage code-explore configuration.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@config_app.command()
+def show() -> None:
+    """Display all current settings with values and sources."""
+    settings = get_resolved_settings()
+    config_path = get_config_path()
+
+    table = Table(title="Code Explore Configuration")
+    table.add_column("Setting", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    table.add_column("Source", style="green")
+
+    for s in settings:
+        table.add_row(s.name, s.value, s.source.value)
+
+    table.add_section()
+    path_display = str(config_path) if config_path else "(no config file)"
+    table.add_row("Config file", path_display, "")
+
+    console.print(table)
+
+
+@config_app.command()
+def init(
+    fmt: str = typer.Option("toml", "--format", "-f", help="Config format: toml or yaml"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing config file"),
+) -> None:
+    """Create a configuration file with all default values."""
+    config_dir = _get_config_dir()
+    ext = "yaml" if fmt in ("yaml", "yml") else "toml"
+    path = config_dir / f"config.{ext}"
+
+    if path.exists() and not force:
+        console.print(
+            f"[yellow]Config file already exists:[/yellow] {path}\n"
+            f"Use [bold]--force[/bold] to overwrite."
+        )
+        raise typer.Exit(1)
+
+    write_default_config(path, fmt=ext)
+    console.print(f"[green]Created configuration file:[/green] {path}")
+
+
+@config_app.command()
+def reset(
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+) -> None:
+    """Delete the configuration file and revert to defaults."""
+    config_path = _discover_config_file()
+
+    if not config_path:
+        console.print("[yellow]No configuration file found. Already using defaults.[/yellow]")
+        raise typer.Exit(0)
+
+    if not yes:
+        confirm = typer.confirm(f"Delete {config_path} and revert to defaults?")
+        if not confirm:
+            console.print("[dim]Cancelled.[/dim]")
+            raise typer.Exit(0)
+
+    config_path.unlink()
+    reset_config()
+    console.print(f"[green]Reset configuration to defaults.[/green] Removed: {config_path}")
+
+
+@config_app.command()
+def path() -> None:
+    """Print the path to the active configuration file."""
+    config_path = _discover_config_file()
+    if config_path:
+        console.print(str(config_path))
+    else:
+        default_path = _get_config_dir() / "config.toml"
+        console.print(f"{default_path} [dim](not created yet)[/dim]")

{code_explore-0.1.0 → code_explore-0.3.0}/code_explore/cli/main.py

@@ -14,12 +14,14 @@ from rich.tree import Tree
 
 from code_explore.database import init_db, save_project, get_project, get_all_projects, get_project_count
 from code_explore.models import Project, ProjectSource, ProjectStatus
+from code_explore.cli.config_cmd import config_app
 
 app = typer.Typer(
     name="code-explore",
     help="Personal developer knowledge base - index, analyze and search all your projects.",
     no_args_is_help=True,
 )
+app.add_typer(config_app, name="config")
 console = Console()
 
 
@@ -142,9 +144,18 @@ def scan(
 def search(
     query: str = typer.Argument(..., help="Search query"),
     mode: str = typer.Option("hybrid", "--mode", "-m", help="Search mode: fulltext, semantic, or hybrid"),
-    limit: int = typer.Option(20, "--limit", "-l", help="Maximum results"),
+    limit: int = typer.Option(None, "--limit", "-l", help="Maximum results"),
+    language: str = typer.Option(None, "--language", "-L", help="Filter by primary language"),
+    framework: str = typer.Option(None, "--framework", "-F", help="Filter by framework"),
+    pattern: str = typer.Option(None, "--pattern", help="Filter by architectural pattern"),
+    tag: str = typer.Option(None, "--tag", "-t", help="Filter by AI-generated tag"),
 ) -> None:
     """Search across all indexed projects."""
+    from code_explore.config import get_config
+    from code_explore.search.filters import apply_filters
+
+    if limit is None:
+        limit = get_config().result_limit
     init_db()
 
     if mode == "fulltext":
@@ -157,6 +168,23 @@ def search(
         from code_explore.search.hybrid import search as hybrid_search
         results = hybrid_search(query, limit=limit)
 
+    # Apply post-filters
+    results = apply_filters(results, language=language, framework=framework, pattern=pattern, tag=tag)
+
+    # Show active filters
+    active_filters = []
+    if language:
+        active_filters.append(f"language={language}")
+    if framework:
+        active_filters.append(f"framework={framework}")
+    if pattern:
+        active_filters.append(f"pattern={pattern}")
+    if tag:
+        active_filters.append(f"tag={tag}")
+
+    if active_filters:
+        console.print(f"[dim]Filters: {', '.join(active_filters)}[/dim]")
+
     if not results:
         console.print(f"[yellow]No results found for:[/yellow] {query}")
         raise typer.Exit(0)
@@ -276,6 +304,16 @@ def show(
     if project.concepts:
         tree.add(f"[bold]Concepts:[/bold] {', '.join(project.concepts)}")
 
+    # AI Tags grouped by category
+    if project.ai_tags:
+        ai_branch = tree.add("[bold]AI Tags[/bold]")
+        by_category: dict[str, list[str]] = {}
+        for t in project.ai_tags:
+            cat = t.category.value if hasattr(t.category, "value") else str(t.category)
+            by_category.setdefault(cat, []).append(t.value)
+        for cat, values in sorted(by_category.items()):
+            ai_branch.add(f"[magenta]{cat}:[/magenta] {', '.join(values)}")
+
     console.print(Panel(tree, title=f"Project: {project.name}", border_style="cyan"))
 
 
@@ -303,22 +341,30 @@ def index(
         MofNCompleteColumn(),
         console=console,
     ) as progress:
-        summary_task = progress.add_task("Generating summaries...", total=len(projects))
+        summary_task = progress.add_task("Generating summaries & AI tags...", total=len(projects))
         summarized = 0
+        tagged = 0
 
         for project in projects:
-            if not project.summary:
+            needs_summary = not project.summary
+            needs_tags = not project.ai_tags
+
+            if needs_summary or needs_tags:
                 progress.update(summary_task, description=f"Summarizing [cyan]{project.name}[/cyan]")
                 if model:
-                    summary, tags, concepts = summarize_project(project, model=model)
+                    summary, tags, concepts, ai_tags = summarize_project(project, model=model)
                 else:
-                    summary, tags, concepts = summarize_project(project)
-                if summary:
+                    summary, tags, concepts, ai_tags = summarize_project(project)
+                if summary and needs_summary:
                     project.summary = summary
                     project.tags = tags
                     project.concepts = concepts
-                    save_project(project)
                     summarized += 1
+                if ai_tags:
+                    project.ai_tags = ai_tags
+                    tagged += 1
+                if summary or ai_tags:
+                    save_project(project)
             progress.update(summary_task, advance=1)
 
         embed_task = progress.add_task("Generating embeddings...", total=len(projects))
@@ -334,7 +380,62 @@ def index(
             indexed += 1
             progress.update(embed_task, advance=1)
 
-    console.print(f"[green]Summarized {summarized} projects, indexed {indexed} projects.[/green]")
+    console.print(f"[green]Summarized {summarized}, AI-tagged {tagged}, indexed {indexed} projects.[/green]")
+
+
+@app.command()
+def tags(
+    category: str = typer.Option(None, "--category", "-c", help="Filter by category: domain, technology-role, maturity"),
+) -> None:
+    """List all unique AI tags across projects with counts."""
+    init_db()
+    projects = get_all_projects()
+
+    if not projects:
+        console.print("[yellow]No projects found. Run 'scan' first.[/yellow]")
+        raise typer.Exit(0)
+
+    # Collect all AI tags with counts
+    tag_counts: Counter[str] = Counter()
+    tag_categories: dict[str, str] = {}
+
+    for p in projects:
+        for t in p.ai_tags:
+            cat = t.category.value if hasattr(t.category, "value") else str(t.category)
+            if category and cat != category:
+                continue
+            tag_counts[t.value] += 1
+            tag_categories[t.value] = cat
+
+    if not tag_counts:
+        if category:
+            console.print(f"[yellow]No AI tags found for category '{category}'.[/yellow]")
+        else:
+            console.print("[yellow]No AI tags found. Run 'cex index' to generate tags.[/yellow]")
+        raise typer.Exit(0)
+
+    # Group by category
+    by_category: dict[str, list[tuple[str, int]]] = {}
+    for tag_value, count in tag_counts.most_common():
+        cat = tag_categories[tag_value]
+        by_category.setdefault(cat, []).append((tag_value, count))
+
+    total_tags = len(tag_counts)
+    total_projects = len(projects)
+    console.print(Panel(
+        f"[bold]{total_tags}[/bold] unique AI tags across [bold]{total_projects}[/bold] projects",
+        title="AI Tags",
+        border_style="magenta",
+    ))
+
+    for cat in sorted(by_category.keys()):
+        items = by_category[cat]
+        table = Table(title=f"{cat} tags")
+        table.add_column("Tag", style="magenta")
+        table.add_column("Projects", justify="right", style="yellow")
+        for tag_value, count in items:
+            table.add_row(tag_value, str(count))
+        console.print(table)
 
 
 @app.command()
@@ -342,6 +443,7 @@ def update(
     force: bool = typer.Option(False, "--force", "-f", help="Re-analyze even if git HEAD unchanged"),
     reindex: bool = typer.Option(False, "--reindex", help="Regenerate embeddings for updated projects"),
     resummarize: bool = typer.Option(False, "--resummarize", help="Regenerate AI summaries for updated projects"),
+    retag: bool = typer.Option(False, "--retag", help="Regenerate AI tags for updated projects"),
 ) -> None:
     """Update existing projects by re-analyzing changed repositories."""
     from datetime import datetime
@@ -427,20 +529,25 @@ def update(
             updated += 1
             progress.update(task, advance=1)
 
-        if resummarize and updated_projects:
+        if (resummarize or retag) and updated_projects:
             from code_explore.summarizer.ollama import summarize_project
 
             summary_task = progress.add_task("Resummarizing...", total=len(updated_projects))
             for project in updated_projects:
                 progress.update(summary_task, description=f"Summarizing [cyan]{project.name}[/cyan]")
-                project.summary = None
-                project.tags = []
-                project.concepts = []
-                summary, tags, concepts = summarize_project(project)
-                if summary:
+                if resummarize:
+                    project.summary = None
+                    project.tags = []
+                    project.concepts = []
+                if retag:
+                    project.ai_tags = []
+                summary, tags, concepts, ai_tags = summarize_project(project)
+                if summary and resummarize:
                     project.summary = summary
                     project.tags = tags
                     project.concepts = concepts
+                if ai_tags and retag:
+                    project.ai_tags = ai_tags
                 save_project(project)
                 progress.update(summary_task, advance=1)
 
@@ -541,12 +648,13 @@ def serve(
     host: str = typer.Option("0.0.0.0", "--host", "-h", help="Bind host"),
     port: int = typer.Option(8000, "--port", "-p", help="Bind port"),
 ) -> None:
-    """Start the FastAPI server."""
+    """Start the FastAPI server with web dashboard."""
     import uvicorn
 
     init_db()
     console.print(Panel(
         f"Starting server on [bold cyan]http://{host}:{port}[/bold cyan]\n"
+        f"Dashboard at [bold cyan]http://{host}:{port}[/bold cyan]\n"
         f"API docs at [bold cyan]http://{host}:{port}/docs[/bold cyan]",
         title="Code Explore API",
     ))