siftcode 0.3.0__py3-none-any.whl → 0.3.1__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.3.1"
 __version_info__ = tuple(int(p) for p in __version__.split(".") if p.isdigit())
-__release_date__ = "2026-10-16"
+__release_date__ = "2026-10-21"
 __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
@@ -86,6 +88,12 @@ 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."
         )
+    except ValueError as e:
+        # load_project now raises ValueError for malformed TOML files.
+        raise SystemExit(
+            f"error: saved project '{name_or_path}' is invalid: {e}\n"
+            f"hint: fix or delete the config file under {PROJECTS_DIR}"
+        )
 
 
 def _check_ollama(client: OllamaClient) -> None:
@@ -109,11 +117,18 @@ 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 +139,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
 # ---------------------------------------------------------------------------
@@ -142,14 +194,22 @@ def cmd_analyze(args: argparse.Namespace) -> int:
     if args.timeout:
         config.model.timeout = args.timeout
 
+    # 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}'")
     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)
@@ -162,56 +222,99 @@ def cmd_analyze(args: argparse.Namespace) -> int:
     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()
+    # One timestamp for the whole run: findings/guide/specs all share it.
+    run_stamp = _stamp()
+    project_stem = _safe_stem(config.name)
+    is_tty = sys.stdout.isatty()
+
+    # ------------------------------------------------------------------
+    # 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)
+            if is_tty:
+                print(f"\r\033[K{msg}", end="", flush=True)
+                if fraction >= 1.0:
+                    print()
+            else:
+                print(msg, flush=True)
 
         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 +327,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 +369,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}'")
@@ -300,6 +415,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}")

siftcode/core/__init__.py

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