siftcode 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

siftcode/__init__.py

@@ -1,3 +1,5 @@
 """Siftcode — local LLM-powered code analysis."""
 
-__version__ = "0.1.0"
+from siftcode._version import __version__
+
+__all__ = ["__version__"]

siftcode/_version.py

@@ -7,9 +7,40 @@ version, name, author, license, and other identifying information.
 
 from __future__ import annotations
 
-__version__ = "0.3.0"
+from typing import Any
+
+
+__all__ = [
+    "__version__",
+    "__version_info__",
+    "__release_date__",
+    "__status__",
+    "APP_ID",
+    "APP_NAME",
+    "APP_SLUG",
+    "APP_TAGLINE",
+    "APP_SUMMARY",
+    "AUTHOR_NAME",
+    "AUTHOR_EMAIL",
+    "COPYRIGHT",
+    "COPYRIGHT_YEAR",
+    "LICENSE_NAME",
+    "LICENSE_SPDX",
+    "LICENSE_URL",
+    "HOMEPAGE_URL",
+    "REPOSITORY_URL",
+    "ISSUES_URL",
+    "CHANGELOG_URL",
+    "DESCRIPTION",
+    "version_string",
+    "short_version",
+    "about_data",
+]
+
+
+__version__ = "0.4.0"
 __version_info__ = tuple(int(p) for p in __version__.split(".") if p.isdigit())
-__release_date__ = "2026-10-16"
+__release_date__ = "2026-11-12"
 __status__ = "beta"
 
 APP_ID = "io.codeberg.lahtis.Siftcode"
@@ -39,19 +70,32 @@ DESCRIPTION = (
     "Everything runs on your own hardware — no code leaves your machine."
 )
 
+
 def version_string() -> str:
+    """Return a human-readable version string, e.g. 'Siftcode 0.3.0 (beta)'."""
     return f"{APP_NAME} {__version__} ({__status__})"
 
+
 def short_version() -> str:
+    """Return just the version number, e.g. '0.3.0'."""
     return __version__
 
-def about_data() -> dict:
+
+def about_data() -> dict[str, Any]:
+    """
+    Return a dictionary of metadata suitable for Gtk.AboutDialog.
+
+    The 'license_type' value is a Gtk.License enum name; 'gpl-3-0-later'
+    matches LICENSE_SPDX = 'GPL-3.0-or-later'. Using 'gpl-3-0' here would
+    incorrectly claim GPL-3.0-only, which is stricter than the project's
+    actual license.
+    """
     return {
         "application_name": APP_NAME,
         "application_icon": APP_ID,
         "version": __version__,
         "developer_name": AUTHOR_NAME,
-        "license_type": "gpl-3-0",
+        "license_type": "gpl-3-0-later",
         "comments": DESCRIPTION,
         "website": HOMEPAGE_URL,
         "issue_url": ISSUES_URL,

siftcode/cli.py

@@ -6,6 +6,7 @@ Provides a thin layer over the core modules:
 - cache: analysis cache management
 - llm: Ollama client
 - analyzer: project analysis engine
+- manual: advanced per-file specification generator
 
 No GTK dependencies.
 """
@@ -14,6 +15,7 @@ from __future__ import annotations
 
 import argparse
 import logging
+import shutil
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -36,13 +38,17 @@ from siftcode.core.analyzer import ProjectAnalyzer
 from siftcode.core.cache import AnalysisCache
 from siftcode.core.config import (
     PROJECTS_DIR,
+    ModelConfig,
     ProjectConfig,
     delete_project,
     list_projects,
     load_project,
     save_project,
 )
-from siftcode.core.llm import LLMError, OllamaClient
+from siftcode.core.llm import (
+    LLMError,
+    OllamaClient,
+)
 from siftcode.core.manual import SpecGenerator
 
 
@@ -86,34 +92,91 @@ def _resolve_project(name_or_path: str) -> ProjectConfig:
             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():
+    except ValueError as e:
+        # load_project now raises ValueError for malformed TOML files.
         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"
+            f"error: saved project '{name_or_path}' is invalid: {e}\n"
+            f"hint: fix or delete the config file under {PROJECTS_DIR}"
         )
 
 
-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 _parse_model_stages(specs: list[str]) -> dict[str, str]:
+    """
+    Parse --model-stage STAGE=MODEL arguments into a dict.
+
+    Raises ValueError with a user-friendly message if any spec is
+    malformed. Used by cmd_analyze before config.validate() so the
+    error is reported as a CLI error (exit 2) rather than a config
+    validation error.
+    """
+    stages: dict[str, str] = {}
+    for spec in specs:
+        if "=" not in spec:
+            raise ValueError(
+                f"--model-stage requires STAGE=MODEL, got {spec!r}.\n"
+                f"Valid stages: {', '.join(ModelConfig.VALID_STAGES)}"
+            )
+        stage, _, model_name = spec.partition("=")
+        stage = stage.strip()
+        model_name = model_name.strip()
+        if not stage or not model_name:
+            raise ValueError(
+                f"--model-stage requires STAGE=MODEL, got {spec!r}.\n"
+                f"Valid stages: {', '.join(ModelConfig.VALID_STAGES)}"
+            )
+        if stage not in ModelConfig.VALID_STAGES:
+            raise ValueError(
+                f"unknown stage '{stage}' in --model-stage.\n"
+                f"Valid stages: {', '.join(ModelConfig.VALID_STAGES)}"
+            )
+        stages[stage] = model_name
+    return stages
+
+
+def _check_ollama(client: OllamaClient, config: ProjectConfig) -> None:
+    """
+    Verify Ollama is reachable AND all configured models are installed.
+
+    The actual diagnosis (DNS vs refused vs timeout) is done by
+    OllamaClient.check_connection() in llm.py, so both the CLI and
+    the GUI get the same user-friendly messages from one place.
+
+    All models referenced by config.model.stages are checked here
+    so a missing model fails at startup, not 20 minutes into a run
+    when the guide stage tries to load it.
+    """
+    try:
+        client.check_connection()
+    except LLMError as e:
+        raise SystemExit(f"error: {e}")
+
+    # Collect every model the run will use: the default plus any
+    # stage-specific overrides.
+    models = {config.model.name} | set(config.model.stages.values())
+    for model in sorted(models):
+        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,
-    )
+    msg = f"  [{bar}] {progress.fraction * 100:5.1f}%  {progress.message}"
+
+    cols = shutil.get_terminal_size().columns
+    if len(msg) > cols - 1:
+        msg = msg[: cols - 4] + "..."
+
+    # Progress bar goes to stderr: visible on screen, but never mixed
+    # into a piped/logged stdout stream. \033[K clears the previous line.
+    print(f"\r\033[K{msg}", end="", file=sys.stderr, flush=True)
+
+    if progress.fraction >= 1.0:
+        print(file=sys.stderr)
 
 
 def _human_size(num_bytes: int) -> str:
@@ -124,6 +187,43 @@ def _human_size(num_bytes: int) -> str:
     return f"{num_bytes:.1f} TB"
 
 
+def _safe_stem(name: str) -> str:
+    """
+    Convert a project name into a filesystem-safe stem.
+
+    Replaces path separators, spaces, and other problematic characters
+    so that a project name like "my/project" doesn't create subdirectories
+    or fail on Windows.
+    """
+    safe = "".join(
+        c if c.isalnum() or c in ("-", "_", ".") else "_"
+        for c in name
+    ).strip("._")
+    return safe or "project"
+
+
+def _stamp() -> str:
+    """Single timestamp used for all output files of one run."""
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def _save_last_run(config: ProjectConfig) -> None:
+    """
+    Persist last_run after a successful analysis.
+
+    Failures are logged but never abort the command: the analysis
+    results are already on disk and more valuable than the timestamp.
+    """
+    config.last_run = datetime.now().isoformat(timespec="seconds")
+    try:
+        save_project(config)
+    except Exception as e:
+        logger.warning(
+            "Could not update last_run for project '%s': %s",
+            config.name, e,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Commands
 # ---------------------------------------------------------------------------
@@ -139,79 +239,149 @@ def cmd_analyze(args: argparse.Namespace) -> int:
         config.model.name = args.model
     if args.num_ctx:
         config.model.num_ctx = args.num_ctx
+    if getattr(args, "spec_num_ctx", None):
+        config.model.spec_num_ctx = args.spec_num_ctx
     if args.timeout:
         config.model.timeout = args.timeout
 
+    # Parse --model-stage arguments into config.model.stages. Done
+    # before validate() so malformed specs are reported as CLI errors
+    # (exit 2) rather than config validation errors.
+    if getattr(args, "model_stage", None):
+        try:
+            config.model.stages.update(
+                _parse_model_stages(args.model_stage)
+            )
+        except ValueError as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 2
+
+    # Validate BEFORE persisting, so we never save a broken config.
+    config.validate()
+
+    # Persist (only if the project already exists as a saved project).
+    # A malformed existing TOML is overwritten with the validated config.
     try:
         load_project(config.name)
         save_project(config)
-        logger.info(f"Updated saved project '{config.name}'")
+        logger.info("Updated saved project '%s'", config.name)
     except FileNotFoundError:
         pass
-
-    config.validate()
+    except ValueError as e:
+        logger.warning(
+            "Existing project config is invalid and will be overwritten: %s", e,
+        )
+        save_project(config)
 
     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()
+    _check_ollama(client, config)
+
+    logger.info("Analyzing: %s", config.path)
+    logger.info("Model:     %s", config.model.name)
+    if config.model.stages:
+        for stage, model_name in sorted(config.model.stages.items()):
+            logger.info("  %-12s %s", f"{stage}:", model_name)
+    logger.info("Context:   %d tokens", config.model.num_ctx)
+    if args.advanced:
+        logger.info("Spec ctx:  %d tokens", config.model.spec_num_ctx)
+
+    # One timestamp for the whole run: findings/guide/specs all share it.
+    run_stamp = _stamp()
+    project_stem = _safe_stem(config.name)
+
+    # ------------------------------------------------------------------
+    # Advanced per-file specification mode
+    # ------------------------------------------------------------------
+    if args.advanced:
+        analyzer = ProjectAnalyzer(config, client)
+        files_to_analyze = analyzer.collect_files()
 
         if not files_to_analyze:
-            print("No Python files found for advanced specification generation.")
+            print("No analyzable 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 = output_dir / f"specs_{project_stem}_{run_stamp}"
         specs_output_dir.mkdir(parents=True, exist_ok=True)
 
-        print(f"Running advanced per-file technical specification for {len(files_to_analyze)} files...")
+        print(f"Running advanced per-file technical specification "
+              f"for {len(files_to_analyze)} files...")
 
         def progress_cb(current: int, total: int, path: Path) -> None:
-            rel = path.relative_to(config.path).as_posix()
+            try:
+                rel = path.relative_to(config.path).as_posix()
+            except ValueError:
+                rel = path.name
             if len(rel) > 35:
                 rel = "..." + rel[-32:]
-            fraction = current / total
+            fraction = current / total if total else 1.0
             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)
+
+            cols = shutil.get_terminal_size().columns
+            if len(msg) > cols - 1:
+                msg = msg[: cols - 4] + "..."
+
+            print(f"\r\033[K{msg}", end="", file=sys.stderr, flush=True)
+            if fraction >= 1.0:
+                print(file=sys.stderr)
 
         try:
-            specs_dict = spec_gen.generate_project_specs(files_to_analyze, progress_callback=progress_cb)
+            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 LLMError as e:
+            print(f"\nerror: {e}", file=sys.stderr)
+            return 1
         except Exception as e:
             print(f"\nerror: {e}", file=sys.stderr)
             return 1
-        
-        # Tallennetaan tiedostot levylle
+
+        # Write specs to disk. generate_project_specs already returns
+        # only successfully processed files, so specs_dict may be
+        # smaller than files_to_analyze. Count the difference and
+        # surface it to the user.
         for rel_path, markdown_content in specs_dict.items():
+            # Guard against rel_path containing '..' segments, which
+            # would let the write escape specs_output_dir.
+            safe_rel = Path(rel_path)
+            if safe_rel.is_absolute() or ".." in safe_rel.parts:
+                logger.warning(
+                    "Skipping unsafe output path: %s", rel_path,
+                )
+                continue
             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")
 
+        _save_last_run(config)
+
+        expected = len(files_to_analyze)
+        written = len(specs_dict)
+        missing = expected - written
+
         print()
-        print(f"✓ Advanced specification generation complete")
+        print("✓ Advanced specification generation complete")
         print(f"  Output directory: {specs_output_dir}")
-        print(f"  Files processed:  {len(specs_dict)}")
+        print(f"  Files processed:  {written}")
+        if missing > 0:
+            print(
+                f"{missing} file(s) failed — see warnings above",
+                file=sys.stderr,
+            )
         return 0
 
-    # NORMAALI ANALYYSI
+    # ------------------------------------------------------------------
+    # Normal analysis
+    # ------------------------------------------------------------------
     analyzer = ProjectAnalyzer(config, client)
 
     try:
@@ -224,14 +394,16 @@ def cmd_analyze(args: argparse.Namespace) -> int:
         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"
+    findings_path = output_dir / f"findings_{project_stem}_{run_stamp}.json"
+    guide_path = output_dir / f"guide_{project_stem}_{run_stamp}.md"
 
     analyzer.findings.save(findings_path)
     guide_path.write_text(analyzer.findings.guide, encoding="utf-8")
 
+    _save_last_run(config)
+
     print()
-    print(f"✓ Analysis complete")
+    print("✓ Analysis complete")
     print(f"  Findings: {findings_path}")
     print(f"  Guide:    {guide_path}")
     print(f"  Errors:   {len(analyzer.findings.errors)}")
@@ -264,6 +436,16 @@ def cmd_add(args: argparse.Namespace) -> int:
             return 1
     except FileNotFoundError:
         pass
+    except ValueError as e:
+        # Malformed existing config — overwrite it (the user asked to
+        # add this project, and --force semantics apply).
+        if not args.force:
+            print(
+                f"error: existing config for '{name}' is invalid: {e}\n"
+                f"hint: use --force to overwrite it",
+                file=sys.stderr,
+            )
+            return 1
 
     path = save_project(config)
     print(f"✓ Saved project '{name}'")
@@ -287,6 +469,11 @@ def cmd_list(args: argparse.Namespace) -> int:
         print(f"  {marker} {p.name}")
         print(f"      path:      {p.path}")
         print(f"      model:     {p.model.name}")
+        if p.model.stages:
+            stages_str = ", ".join(
+                f"{s}={m}" for s, m in sorted(p.model.stages.items())
+            )
+            print(f"      stages:    {stages_str}")
         print(f"      last run:  {last}")
         if p.notes:
             print(f"      notes:     {p.notes}")
@@ -300,6 +487,12 @@ def cmd_show(args: argparse.Namespace) -> int:
     except FileNotFoundError:
         print(f"error: no saved project named '{args.project}'", file=sys.stderr)
         return 1
+    except ValueError as e:
+        print(
+            f"error: saved project '{args.project}' is invalid: {e}",
+            file=sys.stderr,
+        )
+        return 1
 
     print(f"Project: {config.name}")
     print(f"  Path:      {config.path}")
@@ -308,8 +501,17 @@ def cmd_show(args: argparse.Namespace) -> int:
     print()
     print("Model:")
     print(f"  Name:        {config.model.name}")
+    if config.model.stages:
+        print("  Stages:")
+        for stage in ModelConfig.VALID_STAGES:
+            override = config.model.stages.get(stage, "")
+            if override:
+                print(f"    {stage:12s} {override}")
+            else:
+                print(f"    {stage:12s} (default)")
     print(f"  Ollama URL:  {config.model.ollama_url}")
     print(f"  num_ctx:     {config.model.num_ctx}")
+    print(f"  spec_num_ctx: {config.model.spec_num_ctx}")
     print(f"  temperature: {config.model.temperature}")
     print(f"  timeout:     {config.model.timeout}s")
     print()
@@ -433,12 +635,28 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_analyze.add_argument(
         "-m", "--model",
-        help="Override LLM model (e.g. qwen2.5-coder:14b)",
+        help="Override LLM model for all stages (e.g. qwen2.5-coder:14b). "
+             "With 24 GB+ VRAM, use --model-stage for per-stage overrides.",
+    )
+    p_analyze.add_argument(
+        "--model-stage",
+        action="append",
+        default=[],
+        metavar="STAGE=MODEL",
+        help="Override model for a specific stage (repeatable). "
+             "Valid stages: root, file, directories, guide. "
+             "Example: --model-stage guide=qwen2.5-coder:32b",
     )
     p_analyze.add_argument(
         "--num-ctx", type=int,
         help="Override context length in tokens",
     )
+    p_analyze.add_argument(
+        "--spec-num-ctx", type=int,
+        help="Context length for --advanced per-file specs "
+             "(default: 16384). Lower this on GPUs with limited VRAM "
+             "to keep the model fully on the GPU.",
+    )
     p_analyze.add_argument(
         "--timeout", type=int,
         help="Override per-request timeout in seconds",

siftcode/core/__init__.py

@@ -1 +1 @@
-"""Siftcode — local LLM-powered code analysis."""
+"""Core modules for Siftcode: analyzer, cache, config, LLM client, prompts."""