siftcode 0.3.0__py3-none-any.whl

siftcode/__init__.py

@@ -0,0 +1,3 @@
+"""Siftcode — local LLM-powered code analysis."""
+
+__version__ = "0.1.0"

siftcode/__main__.py

@@ -0,0 +1,11 @@
+"""
+Entry point for `python -m siftcode` and the `siftcode` console script.
+"""
+
+import sys
+
+from siftcode.cli import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

siftcode/_version.py

@@ -0,0 +1,59 @@
+"""
+Central metadata for Siftcode.
+
+This module is the single source of truth for the application's
+version, name, author, license, and other identifying information.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.3.0"
+__version_info__ = tuple(int(p) for p in __version__.split(".") if p.isdigit())
+__release_date__ = "2026-10-16"
+__status__ = "beta"
+
+APP_ID = "io.codeberg.lahtis.Siftcode"
+APP_NAME = "Siftcode"
+APP_SLUG = "siftcode"
+APP_TAGLINE = "Local LLM-powered code analysis"
+APP_SUMMARY = "Local LLM-powered code analysis and developer guide generator"
+
+AUTHOR_NAME = "Tuomas Lähteenmäki"
+AUTHOR_EMAIL = "lahtis@gmail.com"
+COPYRIGHT = "© 2026 Tuomas Lähteenmäki"
+COPYRIGHT_YEAR = 2026
+
+LICENSE_NAME = "GNU General Public License v3.0 or later"
+LICENSE_SPDX = "GPL-3.0-or-later"
+LICENSE_URL = "https://www.gnu.org/licenses/gpl-3.0.html"
+
+HOMEPAGE_URL = "https://codeberg.org/lahtis/siftcode"
+REPOSITORY_URL = "https://codeberg.org/lahtis/siftcode"
+ISSUES_URL = "https://codeberg.org/lahtis/siftcode/issues"
+CHANGELOG_URL = "https://codeberg.org/lahtis/siftcode/src/branch/main/CHANGELOG.md"
+
+DESCRIPTION = (
+    "Siftcode analyzes software projects using a locally-running "
+    "language model (via Ollama) and produces per-file summaries, "
+    "per-directory summaries, and a comprehensive Markdown developer guide.\n\n"
+    "Everything runs on your own hardware — no code leaves your machine."
+)
+
+def version_string() -> str:
+    return f"{APP_NAME} {__version__} ({__status__})"
+
+def short_version() -> str:
+    return __version__
+
+def about_data() -> dict:
+    return {
+        "application_name": APP_NAME,
+        "application_icon": APP_ID,
+        "version": __version__,
+        "developer_name": AUTHOR_NAME,
+        "license_type": "gpl-3-0",
+        "comments": DESCRIPTION,
+        "website": HOMEPAGE_URL,
+        "issue_url": ISSUES_URL,
+        "copyright": COPYRIGHT,
+    }

siftcode/cli.py

@@ -0,0 +1,531 @@
+"""
+Command-line interface for Siftcode.
+
+Provides a thin layer over the core modules:
+- config: project save/load/list/delete
+- cache: analysis cache management
+- llm: Ollama client
+- analyzer: project analysis engine
+
+No GTK dependencies.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from siftcode._version import (  # noqa: E402
+    APP_NAME,
+    APP_SLUG,
+    APP_SUMMARY,
+    AUTHOR_NAME,
+    COPYRIGHT,
+    HOMEPAGE_URL,
+    LICENSE_NAME,
+    LICENSE_SPDX,
+    LICENSE_URL,
+    __release_date__,
+    __status__,
+    __version__,
+)
+from siftcode.core.analyzer import ProjectAnalyzer
+from siftcode.core.cache import AnalysisCache
+from siftcode.core.config import (
+    PROJECTS_DIR,
+    ProjectConfig,
+    delete_project,
+    list_projects,
+    load_project,
+    save_project,
+)
+from siftcode.core.llm import LLMError, OllamaClient
+from siftcode.core.manual import SpecGenerator
+
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _setup_logging(verbose: bool, quiet: bool) -> None:
+    if quiet:
+        level = logging.ERROR
+    elif verbose:
+        level = logging.INFO
+    else:
+        level = logging.WARNING
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def _resolve_project(name_or_path: str) -> ProjectConfig:
+    candidate = Path(name_or_path).expanduser()
+
+    if candidate.is_dir():
+        return ProjectConfig(
+            name=candidate.name,
+            path=candidate.resolve(),
+            created=datetime.now().isoformat(timespec="seconds"),
+        )
+
+    try:
+        return load_project(name_or_path)
+    except FileNotFoundError:
+        raise SystemExit(
+            f"error: no project found for '{name_or_path}'\n"
+            f"hint: '{name_or_path}' is not a directory and no saved project "
+            f"matches. Run '{APP_SLUG} list' to see saved projects."
+        )
+
+
+def _check_ollama(client: OllamaClient) -> None:
+    if not client.is_available():
+        raise SystemExit(
+            f"error: cannot reach Ollama at {client.config.ollama_url}\n"
+            f"hint: make sure the Ollama server is running.\n"
+            f"      Try: ollama serve"
+        )
+
+
+def _ensure_model(client: OllamaClient, model: str) -> None:
+    if not client.has_model(model):
+        raise SystemExit(
+            f"error: model '{model}' is not installed in Ollama\n"
+            f"hint: install it with: ollama pull {model}"
+        )
+
+
+def _print_progress(progress) -> None:
+    bar_width = 30
+    filled = int(bar_width * progress.fraction)
+    bar = "█" * filled + "░" * (bar_width - filled)
+    print(
+        f"  [{bar}] {progress.fraction * 100:5.1f}%  {progress.message}",
+        end="\r" if progress.fraction < 1.0 else "\n",
+        flush=True,
+    )
+
+
+def _human_size(num_bytes: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if num_bytes < 1024:
+            return f"{num_bytes:.1f} {unit}"
+        num_bytes /= 1024
+    return f"{num_bytes:.1f} TB"
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+def cmd_analyze(args: argparse.Namespace) -> int:
+    config = _resolve_project(args.project)
+
+    if not config.path.is_dir():
+        print(f"error: project path does not exist: {config.path}", file=sys.stderr)
+        return 1
+
+    if args.model:
+        config.model.name = args.model
+    if args.num_ctx:
+        config.model.num_ctx = args.num_ctx
+    if args.timeout:
+        config.model.timeout = args.timeout
+
+    try:
+        load_project(config.name)
+        save_project(config)
+        logger.info(f"Updated saved project '{config.name}'")
+    except FileNotFoundError:
+        pass
+
+    config.validate()
+
+    output_dir = Path(args.output).expanduser() if args.output else Path.cwd()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    client = OllamaClient(config.model)
+    _check_ollama(client)
+    _ensure_model(client, config.model.name)
+
+    logger.info(f"Analyzing: {config.path}")
+    logger.info(f"Model:     {config.model.name}")
+    logger.info(f"Context:   {config.model.num_ctx} tokens")
+
+    # JOS ADVANCED-LIPPU ON PÄÄLLÄ
+    if getattr(args, "advanced", False):
+        # Kerätään samat tiedostot kuin ProjectAnalyzer (käyttäen sen sääntöjä)
+        temp_analyzer = ProjectAnalyzer(config, client)
+        files_to_analyze = temp_analyzer._collect_files()
+
+        if not files_to_analyze:
+            print("No Python files found for advanced specification generation.")
+            return 0
+
+        spec_gen = SpecGenerator(config=config, client=client)
+        specs_output_dir = output_dir / f"specs_{config.path.name}_{datetime.now():%Y%m%d_%H%M%S}"
+        specs_output_dir.mkdir(parents=True, exist_ok=True)
+
+        print(f"Running advanced per-file technical specification for {len(files_to_analyze)} files...")
+
+        def progress_cb(current: int, total: int, path: Path) -> None:
+            rel = path.relative_to(config.path).as_posix()
+            if len(rel) > 35:
+                rel = "..." + rel[-32:]
+            fraction = current / total
+            bar_width = 20
+            filled = int(bar_width * fraction)
+            bar = "█" * filled + "░" * (bar_width - filled)
+            msg = f"  [{bar}] {fraction * 100:5.1f}%  ({current}/{total}) {rel}"
+            end_char = "\n" if fraction >= 1.0 else ""
+            print(f"\r\033[K{msg}", end=end_char, flush=True)
+
+        try:
+            specs_dict = spec_gen.generate_project_specs(files_to_analyze, progress_callback=progress_cb)
+        except KeyboardInterrupt:
+            print("\n\ninterrupted by user", file=sys.stderr)
+            return 130
+        except Exception as e:
+            print(f"\nerror: {e}", file=sys.stderr)
+            return 1
+        
+        # Tallennetaan tiedostot levylle
+        for rel_path, markdown_content in specs_dict.items():
+            target_file = specs_output_dir / f"{rel_path}.md"
+            target_file.parent.mkdir(parents=True, exist_ok=True)
+            target_file.write_text(markdown_content, encoding="utf-8")
+
+        print()
+        print(f"✓ Advanced specification generation complete")
+        print(f"  Output directory: {specs_output_dir}")
+        print(f"  Files processed:  {len(specs_dict)}")
+        return 0
+
+    # NORMAALI ANALYYSI
+    analyzer = ProjectAnalyzer(config, client)
+
+    try:
+        for progress in analyzer.analyze_project():
+            _print_progress(progress)
+    except KeyboardInterrupt:
+        print("\n\ninterrupted by user", file=sys.stderr)
+        return 130
+    except LLMError as e:
+        print(f"\nerror: {e}", file=sys.stderr)
+        return 1
+
+    findings_path = output_dir / f"findings_{config.path.name}_{datetime.now():%Y%m%d_%H%M%S}.json"
+    guide_path = output_dir / f"guide_{config.path.name}_{datetime.now():%Y%m%d_%H%M%S}.md"
+
+    analyzer.findings.save(findings_path)
+    guide_path.write_text(analyzer.findings.guide, encoding="utf-8")
+
+    print()
+    print(f"✓ Analysis complete")
+    print(f"  Findings: {findings_path}")
+    print(f"  Guide:    {guide_path}")
+    print(f"  Errors:   {len(analyzer.findings.errors)}")
+
+    return 0
+
+
+def cmd_add(args: argparse.Namespace) -> int:
+    project_path = Path(args.path).expanduser().resolve()
+    if not project_path.is_dir():
+        print(f"error: not a directory: {project_path}", file=sys.stderr)
+        return 1
+
+    name = args.name or project_path.name
+    config = ProjectConfig(
+        name=name,
+        path=project_path,
+        created=datetime.now().isoformat(timespec="seconds"),
+        notes=args.notes or "",
+    )
+
+    try:
+        existing = load_project(name)
+        if not args.force:
+            print(
+                f"error: project '{name}' already exists at {existing.path}\n"
+                f"hint: use --force to overwrite, or pick another name",
+                file=sys.stderr,
+            )
+            return 1
+    except FileNotFoundError:
+        pass
+
+    path = save_project(config)
+    print(f"✓ Saved project '{name}'")
+    print(f"  Config: {path}")
+    print(f"  Path:   {project_path}")
+    return 0
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    projects = list_projects()
+
+    if not projects:
+        print("No saved projects.")
+        print(f"Config directory: {PROJECTS_DIR}")
+        return 0
+
+    print(f"{len(projects)} saved project(s):\n")
+    for p in projects:
+        marker = "●" if p.path.is_dir() else "✗"
+        last = p.last_run[:10] if p.last_run else "never"
+        print(f"  {marker} {p.name}")
+        print(f"      path:      {p.path}")
+        print(f"      model:     {p.model.name}")
+        print(f"      last run:  {last}")
+        if p.notes:
+            print(f"      notes:     {p.notes}")
+        print()
+    return 0
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    try:
+        config = load_project(args.project)
+    except FileNotFoundError:
+        print(f"error: no saved project named '{args.project}'", file=sys.stderr)
+        return 1
+
+    print(f"Project: {config.name}")
+    print(f"  Path:      {config.path}")
+    print(f"  Created:   {config.created or '(unknown)'}")
+    print(f"  Last run:  {config.last_run or 'never'}")
+    print()
+    print("Model:")
+    print(f"  Name:        {config.model.name}")
+    print(f"  Ollama URL:  {config.model.ollama_url}")
+    print(f"  num_ctx:     {config.model.num_ctx}")
+    print(f"  temperature: {config.model.temperature}")
+    print(f"  timeout:     {config.model.timeout}s")
+    print()
+    print("Analysis:")
+    print(f"  use_cache:       {config.analysis.use_cache}")
+    print(f"  max_file_chars: {config.analysis.max_file_chars}")
+    print(f"  exclude:         {len(config.analysis.exclude)} entries")
+    print(f"                   {', '.join(config.analysis.exclude[:5])}...")
+    if config.notes:
+        print()
+        print(f"Notes: {config.notes}")
+    return 0
+
+
+def cmd_delete(args: argparse.Namespace) -> int:
+    if not args.yes:
+        answer = input(f"Delete project '{args.project}'? [y/N] ").strip().lower()
+        if answer not in ("y", "yes"):
+            print("Aborted.")
+            return 0
+
+    if delete_project(args.project):
+        print(f"✓ Deleted project '{args.project}'")
+        return 0
+    print(f"error: no saved project named '{args.project}'", file=sys.stderr)
+    return 1
+
+
+def cmd_cache_stats(args: argparse.Namespace) -> int:
+    cache = AnalysisCache()
+    s = cache.stats()
+
+    print(f"Cache directory: {s['base_dir']}")
+    print()
+    print(f"{'Category':<15} {'Entries':>10} {'Size':>12}")
+    print(f"{'-' * 15} {'-' * 10} {'-' * 12}")
+    for name in ("files", "directories", "roots"):
+        info = s[name]
+        print(f"{name:<15} {info['entries']:>10} {_human_size(info['bytes']):>12}")
+    print(f"{'-' * 15} {'-' * 10} {'-' * 12}")
+    print(f"{'Total':<15} {s['total']['entries']:>10} {s['total']['human_size']:>12}")
+    return 0
+
+
+def cmd_cache_clear(args: argparse.Namespace) -> int:
+    cache = AnalysisCache()
+
+    if args.model:
+        if not args.yes:
+            answer = input(f"Clear cache for model '{args.model}'? [y/N] ").strip().lower()
+            if answer not in ("y", "yes"):
+                print("Aborted.")
+                return 0
+        removed = cache.clear(model=args.model)
+        print(f"✓ Removed {removed} cache entries for model '{args.model}'")
+    else:
+        if not args.yes:
+            answer = input("Clear the ENTIRE cache? [y/N] ").strip().lower()
+            if answer not in ("y", "yes"):
+                print("Aborted.")
+                return 0
+        removed = cache.clear()
+        print(f"✓ Removed {removed} cache entries")
+
+    return 0
+
+
+def cmd_cache_gc(args: argparse.Namespace) -> int:
+    cache = AnalysisCache()
+    removed = cache.gc(max_age_days=args.days)
+    print(f"✓ Removed {removed} cache entries older than {args.days} days")
+    return 0
+
+
+def cmd_about(args: argparse.Namespace) -> int:
+    """Print version, author, and license info."""
+    print(f"{APP_NAME} {__version__} ({__status__})")
+    print(f"Released: {__release_date__}")
+    print()
+    print(APP_SUMMARY)
+    print()
+    print(f"Author:    {AUTHOR_NAME}")
+    print(f"Copyright: {COPYRIGHT}")
+    print(f"License:   {LICENSE_NAME}")
+    print(f"           {LICENSE_URL}")
+    print()
+    print(f"Homepage:  {HOMEPAGE_URL}")
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Parser
+# ---------------------------------------------------------------------------
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=APP_SLUG,
+        description=APP_SUMMARY,
+        epilog=f"Licensed under {LICENSE_SPDX}. See '{APP_SLUG} about' for details.",
+    )
+    parser.add_argument(
+        "--version", action="version",
+        version=f"{APP_SLUG} {__version__}",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true",
+        help="enable debug logging",
+    )
+    parser.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="only show warnings and errors",
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # analyze
+    p_analyze = sub.add_parser("analyze", help="Analyze a project")
+    p_analyze.add_argument(
+        "project",
+        help="Path to project directory, or name of a saved project",
+    )
+    p_analyze.add_argument(
+        "-m", "--model",
+        help="Override LLM model (e.g. qwen2.5-coder:14b)",
+    )
+    p_analyze.add_argument(
+        "--num-ctx", type=int,
+        help="Override context length in tokens",
+    )
+    p_analyze.add_argument(
+        "--timeout", type=int,
+        help="Override per-request timeout in seconds",
+    )
+    p_analyze.add_argument(
+        "-o", "--output", default=".",
+        help="Directory for findings.json and guide.md (default: .)",
+    )
+    p_analyze.add_argument(
+        "--advanced", action="store_true",
+        help="Run advanced per-file technical specification generator.",
+    )
+    p_analyze.set_defaults(func=cmd_analyze)
+
+    # add
+    p_add = sub.add_parser("add", help="Register a project directory")
+    p_add.add_argument("path", help="Path to project directory")
+    p_add.add_argument("-n", "--name", help="Name to save under (default: dir name)")
+    p_add.add_argument("--notes", help="Optional notes")
+    p_add.add_argument("--force", action="store_true", help="Overwrite existing")
+    p_add.set_defaults(func=cmd_add)
+
+    # list
+    p_list = sub.add_parser("list", help="List saved projects")
+    p_list.set_defaults(func=cmd_list)
+
+    # show
+    p_show = sub.add_parser("show", help="Show a project's configuration")
+    p_show.add_argument("project", help="Saved project name")
+    p_show.set_defaults(func=cmd_show)
+
+    # delete
+    p_del = sub.add_parser("delete", help="Delete a saved project")
+    p_del.add_argument("project", help="Saved project name")
+    p_del.add_argument("-y", "--yes", action="store_true", help="Skip confirmation")
+    p_del.set_defaults(func=cmd_delete)
+
+    # cache
+    p_cache = sub.add_parser("cache", help="Manage the analysis cache")
+    cache_sub = p_cache.add_subparsers(dest="cache_command", required=True)
+
+    p_cache_stats = cache_sub.add_parser("stats", help="Show cache statistics")
+    p_cache_stats.set_defaults(func=cmd_cache_stats)
+
+    p_cache_clear = cache_sub.add_parser("clear", help="Clear cache entries")
+    p_cache_clear.add_argument(
+        "--model",
+        help="Only clear entries for this model (default: all)",
+    )
+    p_cache_clear.add_argument(
+        "-y", "--yes", action="store_true",
+        help="Skip confirmation prompt",
+    )
+    p_cache_clear.set_defaults(func=cmd_cache_clear)
+
+    p_cache_gc = cache_sub.add_parser("gc", help="Remove old cache entries")
+    p_cache_gc.add_argument(
+        "--days", type=float, default=30.0,
+        help="Remove entries not used in N days (default: 30)",
+    )
+    p_cache_gc.set_defaults(func=cmd_cache_gc)
+
+    # about
+    p_about = sub.add_parser("about", help="Show version, author, and license")
+    p_about.set_defaults(func=cmd_about)
+
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    _setup_logging(getattr(args, "verbose", False), getattr(args, "quiet", False))
+
+    try:
+        return args.func(args)
+    except SystemExit as e:
+        if isinstance(e.code, str):
+            print(e.code, file=sys.stderr)
+            return 2
+        return e.code if isinstance(e.code, int) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

siftcode/core/__init__.py

@@ -0,0 +1 @@
+"""Siftcode — local LLM-powered code analysis."""