code-explore 0.2.0__tar.gz → 0.4.0__tar.gz

code_explore-0.4.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.2.0 → code_explore-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-explore
-Version: 0.2.0
+Version: 0.4.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

{code_explore-0.2.0 → code_explore-0.4.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.4.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.2.0 → code_explore-0.4.0}/code_explore/cli/main.py

@@ -34,8 +34,11 @@ def scan(
     path: str = typer.Argument(..., help="Root directory to scan for repositories"),
     depth: int = typer.Option(4, "--depth", "-d", help="Maximum directory depth"),
     force: bool = typer.Option(False, "--force", "-f", help="Re-scan existing projects"),
+    no_ai: bool = typer.Option(False, "--no-ai", help="Skip AI summaries and tags (requires Ollama)"),
+    no_embed: bool = typer.Option(False, "--no-embed", help="Skip vector embeddings"),
+    model: str | None = typer.Option(None, "--model", "-m", help="Ollama model name"),
 ) -> None:
-    """Scan a local directory for git repositories and analyze them."""
+    """Scan repositories, analyze, summarize, and index — all in one step."""
     from code_explore.scanner.local import scan_local_repos
     from code_explore.scanner.git_info import extract_git_info, get_git_head
     from code_explore.scanner.readme import read_readme, list_key_files
@@ -51,7 +54,16 @@ def scan(
         console.print(f"[red]Error:[/red] Path does not exist: {root}")
         raise typer.Exit(1)
 
-    console.print(Panel(f"Scanning [bold cyan]{root}[/bold cyan] (depth={depth})", title="Code Explore"))
+    steps = ["scan", "analyze"]
+    if not no_ai:
+        steps.append("summarize + tag")
+    if not no_embed:
+        steps.append("embed")
+    console.print(Panel(
+        f"Scanning [bold cyan]{root}[/bold cyan] (depth={depth})\n"
+        f"Steps: {' → '.join(steps)}",
+        title="Code Explore",
+    ))
 
     repos = asyncio.run(scan_local_repos(root, max_depth=depth))
 
@@ -60,6 +72,7 @@ def scan(
         raise typer.Exit(0)
 
     results: list[Project] = []
+    new_or_changed: list[Project] = []
 
     with Progress(
         SpinnerColumn(),
@@ -68,6 +81,7 @@ def scan(
         MofNCompleteColumn(),
         console=console,
     ) as progress:
+        # Phase 1: Scan & analyze
         task = progress.add_task("Analyzing repositories...", total=len(repos))
 
         for repo_path in repos:
@@ -117,8 +131,55 @@ def scan(
 
             save_project(project)
             results.append(project)
+            new_or_changed.append(project)
             progress.update(task, advance=1)
 
+        # Phase 2: AI summaries & tags (all projects that need them)
+        if not no_ai:
+            from code_explore.summarizer.ollama import summarize_project
+
+            ai_candidates = [p for p in results if not p.summary or not p.ai_tags]
+            if ai_candidates:
+                ai_task = progress.add_task("AI summaries & tags...", total=len(ai_candidates))
+                summarized = 0
+                tagged = 0
+
+                for project in ai_candidates:
+                    progress.update(ai_task, description=f"Summarizing [cyan]{project.name}[/cyan]")
+                    needs_summary = not project.summary
+                    needs_tags = not project.ai_tags
+
+                    if model:
+                        summary, tags, concepts, ai_tags = summarize_project(project, model=model)
+                    else:
+                        summary, tags, concepts, ai_tags = summarize_project(project)
+
+                    if summary and needs_summary:
+                        project.summary = summary
+                        project.tags = tags
+                        project.concepts = concepts
+                        summarized += 1
+                    if ai_tags and needs_tags:
+                        project.ai_tags = ai_tags
+                        tagged += 1
+                    if summary or ai_tags:
+                        save_project(project)
+                    progress.update(ai_task, advance=1)
+
+        # Phase 3: Embeddings (all projects)
+        if not no_embed:
+            from code_explore.indexer.embeddings import index_project as embed_project
+            from datetime import datetime
+
+            embed_task = progress.add_task("Generating embeddings...", total=len(results))
+            for project in results:
+                progress.update(embed_task, description=f"Embedding [cyan]{project.name}[/cyan]")
+                embed_project(project)
+                project.status = ProjectStatus.INDEXED
+                project.indexed_at = datetime.now()
+                save_project(project)
+                progress.update(embed_task, advance=1)
+
     table = Table(title=f"Scanned {len(results)} Projects")
     table.add_column("Name", style="cyan", no_wrap=True)
     table.add_column("Language", style="green")
@@ -145,9 +206,14 @@ 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(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
@@ -163,6 +229,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)
@@ -282,6 +365,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"))
 
 
@@ -289,7 +382,7 @@ def show(
 def index(
     model: str | None = typer.Option(None, "--model", "-m", help="Ollama model name for summarization"),
 ) -> None:
-    """Generate embeddings and AI summaries for all projects."""
+    """Re-generate AI summaries and embeddings for existing projects."""
     from code_explore.indexer.embeddings import index_project as embed_project, index_all_projects
     from code_explore.summarizer.ollama import summarize_project
 
@@ -309,22 +402,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))
@@ -340,7 +441,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()
@@ -348,6 +504,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
@@ -433,20 +590,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)
 
@@ -547,12 +709,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",
     ))

{code_explore-0.2.0 → code_explore-0.4.0}/code_explore/database.py

@@ -110,7 +110,10 @@ def init_db(db_path: Path | None = None) -> None:
 def save_project(project: Project, db_path: Path | None = None) -> None:
     conn = get_connection(db_path)
     now = datetime.now().isoformat()
-    tags_str = ", ".join(project.tags) if project.tags else ""
+    tag_parts = list(project.tags) if project.tags else []
+    if project.ai_tags:
+        tag_parts.extend(t.value for t in project.ai_tags)
+    tags_str = ", ".join(tag_parts)
 
     readme_str = (project.readme_snippet or "")[:2000]
 

{code_explore-0.2.0 → code_explore-0.4.0}/code_explore/indexer/embeddings.py

@@ -93,6 +93,11 @@ def _project_to_text(project: Project) -> str:
     if project.concepts:
         parts.append(f"Concepts: {', '.join(project.concepts)}")
 
+    # AI classification tags
+    if project.ai_tags:
+        ai_tag_values = [t.value for t in project.ai_tags]
+        parts.append(f"AI Tags: {', '.join(ai_tag_values)}")
+
     # Language names
     languages = [lang.name for lang in project.languages]
     if languages:

{code_explore-0.2.0 → code_explore-0.4.0}/code_explore/models.py

@@ -20,6 +20,18 @@ class ProjectStatus(str, Enum):
     ERROR = "error"
 
 
+class TagCategory(str, Enum):
+    DOMAIN = "domain"
+    TECHNOLOGY_ROLE = "technology-role"
+    MATURITY = "maturity"
+
+
+class AiTag(BaseModel):
+    value: str
+    category: TagCategory = TagCategory.DOMAIN
+    confidence: float = 0.8
+
+
 class LanguageInfo(BaseModel):
     name: str
     files: int = 0
@@ -82,6 +94,7 @@ class Project(BaseModel):
     summary: str | None = None
     tags: list[str] = Field(default_factory=list)
     concepts: list[str] = Field(default_factory=list)
+    ai_tags: list[AiTag] = Field(default_factory=list)
 
     readme_snippet: str | None = None
     key_files: list[str] = Field(default_factory=list)
@@ -104,3 +117,15 @@ class SearchQuery(BaseModel):
     mode: str = "hybrid"
     limit: int = 20
     filters: dict = Field(default_factory=dict)
+    language: str | None = None
+    framework: str | None = None
+    pattern: str | None = None
+    tag: str | None = None
+
+
+class SearchFacets(BaseModel):
+    languages: dict[str, int] = Field(default_factory=dict)
+    frameworks: dict[str, int] = Field(default_factory=dict)
+    patterns: dict[str, int] = Field(default_factory=dict)
+    tags: dict[str, int] = Field(default_factory=dict)
+    total: int = 0