knowcode 0.1.0__py3-none-any.whl

runtime/cli/animation.py

@@ -0,0 +1,278 @@
+"""Logo animation module for KnowCode CLI."""
+
+from __future__ import annotations
+
+import math
+import re
+import shutil
+import sys
+import threading
+import time
+
+if sys.stdout.encoding != "utf-8":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+HIDE_CURSOR = "\033[?25l"
+SHOW_CURSOR = "\033[?25h"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+RESET = "\033[0m"
+WHITE = "\033[97m"
+GRAY = "\033[90m"
+
+LOGO_LINES = [
+    "███████████████████████████",
+    "██                       ██",
+    "██    ███████████████    ██",
+    "██    █████▀   ▀█████    ██",
+    "██    █████▄   ▄█████    ██",
+    "██    ███████ ███████    ██",
+    "██    █████▀   ▀█████    ██",
+    "██    █████▄   ▄█████    ██",
+    "██    ███████████████    ██",
+    "██                       ██",
+    "███████████████████████████",
+]
+
+LOGO_HEIGHT = len(LOGO_LINES)
+LOGO_WIDTH = len(LOGO_LINES[0])
+LEFT_BLOCK_WIDTH = LOGO_WIDTH + 6
+
+LXN = LOGO_WIDTH - 1
+LYN = LOGO_HEIGHT - 1
+TAGLINE = "KnowCode"
+VERSION = "v0.1.0"
+
+
+def move_up(n: int) -> None:
+    if n > 0:
+        sys.stdout.write(f"\033[{n}A")
+
+
+def write(s: str) -> None:
+    sys.stdout.write(s)
+    sys.stdout.flush()
+
+
+ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+
+def visible_len(s: str) -> int:
+    """Calculate the printed length of a string, excluding ANSI escape sequences."""
+    return len(ANSI_ESCAPE.sub("", s))
+
+
+def pad_left(s: str, width: int) -> str:
+    """Pad a string to a specific visible width by appending spaces."""
+    v_len = visible_len(s)
+    if v_len < width:
+        return s + " " * (width - v_len)
+    return s
+
+
+class BackgroundAnimator:
+    """Animate the KnowCode logo in the background while tasks execute."""
+
+    def __init__(self):
+        self.status = "Starting..."
+        self.running = False
+        self._thread = None
+        self.tagline_visible_chars = 0
+        self.connector_visible_chars = 0
+        self.last_height = None
+        self.is_tty = sys.stdout.isatty()
+        self.phase = 0
+
+    def start(self) -> None:
+        """Start the animation in a background thread if running in an interactive terminal."""
+        if not self.is_tty:
+            return
+
+        write(HIDE_CURSOR)
+
+        cols, lines = shutil.get_terminal_size()
+
+        # Reserve screen lines initially depending on terminal size
+        if lines < LOGO_HEIGHT + 2 or cols < 74:
+            self.last_height = 0
+        else:
+            write("\n" * (LOGO_HEIGHT + 1))
+            self.last_height = LOGO_HEIGHT + 1
+
+        self.running = True
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(
+        self, final_status: str = "Ready", results: list[str] | None = None
+    ) -> None:
+        """Stop the animation and print the final static state."""
+        if not self.is_tty:
+            if results:
+                for r_line in results:
+                    write(f"{r_line}\n")
+            return
+
+        if self.running:
+            self.status = final_status
+
+            # Enforce a minimum animation duration (up to phase 40, approx 1.4s)
+            # so that the circular reveal animation has time to be visible
+            while self.phase < 40:
+                time.sleep(0.05)
+
+            self.running = False
+            if self._thread:
+                self._thread.join()
+
+            # Reposition to the top of our last frame before printing final state
+            if self.last_height and self.last_height > 0:
+                move_up(self.last_height)
+                write("\033[J")
+
+            # Print final clean state
+            self._print_final(results)
+
+        write(SHOW_CURSOR)
+
+    def _get_colored_char(self, char: str, x: int, y: int, R: float) -> str:
+        if char == " ":
+            return " "
+
+        dx = (x - LXN / 2) * 0.6
+        dy = y - LYN / 2
+        d = math.sqrt(dx * dx + dy * dy)
+
+        if d > R:
+            return " "
+        elif R - 1.5 < d <= R:
+            theta = math.atan2(dy, dx)
+            hue_idx = int(((theta + math.pi) / (2 * math.pi)) * 6) % 6
+            colors = [
+                "\033[1;91m",
+                "\033[1;93m",
+                "\033[1;92m",
+                "\033[1;96m",
+                "\033[1;94m",
+                "\033[1;95m",
+            ]
+            return f"{colors[hue_idx]}{char}{RESET}"
+        else:
+            return f"{BOLD}{WHITE}{char}{RESET}"
+
+    def _run(self) -> None:
+        self.phase = 0
+        R_max = 12.5
+        cycle = 80
+
+        while self.running:
+            cols, lines = shutil.get_terminal_size()
+
+            # Determine display mode based on terminal size
+            if lines < LOGO_HEIGHT + 2 or cols < 74:
+                mode = "single"
+                current_height = 0
+            else:
+                mode = "full"
+                current_height = LOGO_HEIGHT + 1
+
+            # Move cursor back to the top of the previous frame
+            if self.last_height and self.last_height > 0:
+                move_up(self.last_height)
+                if current_height < self.last_height:
+                    write("\033[J")
+
+            if mode == "single":
+                max_width = max(10, cols - 6)
+                status_text = self.status
+                if len(status_text) > max_width:
+                    status_text = status_text[: max_width - 3] + "..."
+                write(f"\r  ● {status_text:<{max_width}}")
+            else:
+                s = self.phase % cycle
+                R = R_max * (1 - math.cos(s * math.pi / 40)) / 2
+
+                left_lines = []
+                for y, line in enumerate(LOGO_LINES):
+                    animated_line_chars = []
+                    for x, char in enumerate(line):
+                        animated_line_chars.append(
+                            self._get_colored_char(char, x, y, R)
+                        )
+                    left_lines.append(f"  {''.join(animated_line_chars)}")
+
+                # Tagline and active status side-by-side components on the right
+                right_width = cols - LEFT_BLOCK_WIDTH - 4
+                status_max = max(15, right_width - 2)
+                status_text = self.status
+                if len(status_text) > status_max:
+                    status_text = status_text[: status_max - 3] + "..."
+
+                separator_len = min(31, right_width)
+                right_lines = [
+                    f"{GRAY}{TAGLINE}    {DIM}{GRAY}{VERSION}{RESET}",
+                    f"{GRAY}{'─' * separator_len}{RESET}",
+                    "",
+                    f"{WHITE}● {status_text:<{status_max}}{RESET}",
+                ]
+
+                buffer = ["\n"]
+                max_len = max(len(left_lines), len(right_lines))
+                for i in range(max_len):
+                    left = (
+                        left_lines[i] if i < len(left_lines) else " " * LEFT_BLOCK_WIDTH
+                    )
+                    right = right_lines[i] if i < len(right_lines) else ""
+                    buffer.append(f"{pad_left(left, LEFT_BLOCK_WIDTH)}{right}\n")
+
+                write("".join(buffer))
+
+            self.last_height = current_height
+            self.phase += 1
+            time.sleep(0.035)
+
+    def _print_final(self, results: list[str] | None = None) -> None:
+        cols, lines = shutil.get_terminal_size()
+
+        if lines < LOGO_HEIGHT + 4 or cols < 80:
+            max_width = max(10, cols - 6)
+            status_text = self.status
+            if len(status_text) > max_width:
+                status_text = status_text[: max_width - 3] + "..."
+            write(f"\r  {WHITE}✔ {status_text:<{max_width}}{RESET}\n")
+            if results:
+                for r_line in results:
+                    write(f"{r_line}\n")
+        else:
+            left_lines = []
+            for line in LOGO_LINES:
+                left_lines.append(f"  {BOLD}{WHITE}{line}{RESET}")
+
+            right_width = cols - LEFT_BLOCK_WIDTH - 4
+            status_max = max(15, right_width - 2)
+            status_text = self.status
+            if len(status_text) > status_max:
+                status_text = status_text[: status_max - 3] + "..."
+
+            separator_len = min(31, right_width)
+            right_lines = [
+                f"{GRAY}{TAGLINE}    {DIM}{GRAY}{VERSION}{RESET}",
+                f"{GRAY}{'─' * separator_len}{RESET}",
+                "",
+                f"{WHITE}✔ {status_text:<{status_max}}{RESET}",
+                "",
+            ]
+            if results:
+                right_lines.extend(results)
+
+            buffer = ["\n"]
+            max_len = max(len(left_lines), len(right_lines))
+            for i in range(max_len):
+                left = left_lines[i] if i < len(left_lines) else " " * LEFT_BLOCK_WIDTH
+                right = right_lines[i] if i < len(right_lines) else ""
+                buffer.append(f"{pad_left(left, LEFT_BLOCK_WIDTH)}{right}\n")
+
+            write("".join(buffer))

runtime/cli/app.py

@@ -0,0 +1,309 @@
+"""KnowCode CLI.
+
+The top-level Typer application providing the ``know`` command.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import structlog
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from runtime.exceptions.errors import KnowcodeError
+from runtime.services.init_service import run_init
+from runtime.services.status_service import run_status
+from runtime.services.sync_service import run_sync
+from runtime.cli.animation import BackgroundAnimator
+from runtime.cli.auth import ensure_authenticated
+from runtime.cli.telemetry import send_telemetry_async
+import shutil
+
+app = typer.Typer(
+    name="knowcode",
+    help="KnowCode Structural Cognition Engine",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+console = Console()
+animator = BackgroundAnimator()
+
+
+def _capture_console_lines(renderable) -> list[str]:
+    """Capture rich console output and split it into clean string lines constrained to right column."""
+    if sys.stdout.isatty():
+        cols, lines = shutil.get_terminal_size()
+        if cols >= 80 and lines >= 14:
+            right_width = max(20, cols - 35 - 4)
+        else:
+            right_width = max(20, cols - 4)
+        from rich.console import Console as RichConsole
+
+        temp_console = RichConsole(width=right_width, color_system=console.color_system)
+    else:
+        temp_console = console
+
+    with temp_console.capture() as capture:
+        temp_console.print(renderable)
+    return capture.get().rstrip().split("\n")
+
+
+def _update_animator(logger, method_name, event_dict):
+    if animator and animator.running:
+        animator.status = str(event_dict.get("event", "Processing..."))
+    return event_dict
+
+
+def _setup_logging() -> None:
+    """Configure minimal JSON logging for the entire ecosystem."""
+    structlog.configure(
+        processors=[
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer(),
+        ],
+        logger_factory=structlog.PrintLoggerFactory(
+            file=open("knowcode.log", "a", encoding="utf-8")
+        ),
+    )
+
+
+_setup_logging()
+
+
+def _handle_error(e: Exception) -> None:
+    """Print an error nicely and exit."""
+    if isinstance(e, KnowcodeError):
+        console.print(f"[red]Error:[/red] {e}")
+    else:
+        console.print(f"[bold red]Unexpected Error:[/bold red] {e}")
+    sys.exit(1)
+
+
+@app.command(".")
+def init_command() -> None:
+    """Initialize a new KnowCode instance in the current repository."""
+    try:
+        ensure_authenticated()
+    except Exception as e:
+        _handle_error(e)
+
+    animator.start()
+    try:
+        cwd = Path.cwd()
+        result = run_init(cwd)
+        panel = Panel.fit(
+            f"[bold green]{result.message}[/bold green]\n"
+            f"Structural Revision: [cyan]{result.structural_revision}[/cyan]\n"
+            f"Initial Snapshot: [cyan]{result.snapshot_file}[/cyan]\n\n"
+            f"[bold yellow]Next Step:[/bold yellow] Type [magenta]/knowcode[/magenta] in your AI chat to activate governance.",
+            title="KnowCode Initialization",
+            border_style="green",
+        )
+        results_lines = _capture_console_lines(panel)
+        animator.stop(final_status="Initialization complete.", results=results_lines)
+        send_telemetry_async("init", "success")
+    except Exception as e:
+        animator.stop(final_status="Initialization failed.")
+        send_telemetry_async("init", "failed")
+        _handle_error(e)
+
+
+@app.command("init")
+def init_alias_command() -> None:
+    """Initialize a new KnowCode instance in the current repository."""
+    init_command()
+
+
+@app.command("sync")
+def sync_command() -> None:
+    """Synchronize the KnowCode artifact with the current repository state."""
+    try:
+        ensure_authenticated()
+    except Exception as e:
+        _handle_error(e)
+
+    animator.start()
+    try:
+        cwd = Path.cwd()
+        result = run_sync(cwd)
+
+        if not result.changes_detected:
+            results_lines = _capture_console_lines(f"[green]✓[/green] {result.message}")
+            animator.stop(final_status="Sync complete.", results=results_lines)
+            send_telemetry_async("sync", "success")
+            return
+
+        table = Table(title="Sync Results", show_header=False)
+        table.add_column("Key", style="dim")
+        table.add_column("Value", style="cyan")
+
+        table.add_row("Revision", result.structural_revision)
+        table.add_row("Snapshot", result.snapshot_file)
+        table.add_row("Report", result.report_file)
+        table.add_row(
+            "Components",
+            ", ".join(result.affected_components)
+            if result.affected_components
+            else "None",
+        )
+
+        panel = Panel.fit(
+            table, title="[bold green]Sync Complete[/bold green]", border_style="green"
+        )
+        results_lines = _capture_console_lines(panel)
+        animator.stop(final_status="Sync complete.", results=results_lines)
+        send_telemetry_async("sync", "success")
+
+    except Exception as e:
+        animator.stop(final_status="Sync failed.")
+        send_telemetry_async("sync", "failed")
+        _handle_error(e)
+
+
+@app.command("status")
+def status_command() -> None:
+    """View the current status of the KnowCode instance."""
+    try:
+        ensure_authenticated()
+    except Exception as e:
+        _handle_error(e)
+
+    animator.start()
+    try:
+        cwd = Path.cwd()
+        result = run_status(cwd)
+
+        table = Table(
+            title=f"KnowCode Status: {result.repository_root}", show_header=False
+        )
+        table.add_column("Key", style="dim")
+        table.add_column("Value", style="bold")
+
+        table.add_row(
+            "Initialized",
+            "[green]Yes[/green]" if result.initialized else "[red]No[/red]",
+        )
+        table.add_row(
+            "Structural Revision", f"[cyan]{result.structural_revision}[/cyan]"
+        )
+        table.add_row(
+            "Semantic Revision", f"[magenta]{result.semantic_revision}[/magenta]"
+        )
+        table.add_row("Current Snapshot", result.current_snapshot)
+        table.add_row("Latest Report", result.latest_report)
+
+        last_sync = (
+            result.last_sync.strftime("%Y-%m-%d %H:%M:%S UTC")
+            if result.last_sync
+            else "Never"
+        )
+        table.add_row("Last Sync", last_sync)
+
+        results_lines = _capture_console_lines(table)
+        animator.stop(final_status="Status retrieved.", results=results_lines)
+        send_telemetry_async("status", "success")
+
+    except Exception as e:
+        animator.stop(final_status="Failed to get status.")
+        send_telemetry_async("status", "failed")
+        _handle_error(e)
+
+
+@app.command("sync-semantic")
+def sync_semantic_command() -> None:
+    """Commit semantic changes and flush the active memory buffer."""
+    try:
+        ensure_authenticated()
+    except Exception as e:
+        _handle_error(e)
+
+    animator.start()
+    try:
+        from runtime.services.semantic_sync_service import run_semantic_sync
+
+        cwd = Path.cwd()
+        result = run_semantic_sync(cwd)
+
+        table = Table(title="Semantic Sync Results", show_header=False)
+        table.add_column("Key", style="dim")
+        table.add_column("Value", style="magenta")
+
+        table.add_row("Revision", result.semantic_revision)
+        table.add_row("Memory", "[dim]Flushed previous_context.md[/dim]")
+
+        panel = Panel.fit(
+            table,
+            title=f"[bold magenta]✓ {result.message}[/bold magenta]",
+            border_style="magenta",
+        )
+        results_lines = _capture_console_lines(panel)
+        animator.stop(final_status="Semantic sync complete.", results=results_lines)
+        send_telemetry_async("sync-semantic", "success")
+
+    except Exception as e:
+        animator.stop(final_status="Semantic sync failed.")
+        send_telemetry_async("sync-semantic", "failed")
+        _handle_error(e)
+
+
+@app.command("ingest-semantic")
+def ingest_semantic_command(
+    target_file: str = typer.Argument(
+        ..., help="Path to the raw file to ingest and remove, or '.' to process all."
+    ),
+) -> None:
+    """Ingest a legacy document and bump the semantic revision."""
+    animator.start()
+    try:
+        from runtime.services.ingest_service import run_ingest
+
+        cwd = Path.cwd()
+        result = run_ingest(cwd, target_file)
+        animator.stop(final_status="Semantic ingest complete.")
+
+        if result.semantic_revision == "No change":
+            console.print(f"[yellow]ℹ {result.message}[/yellow]")
+            return
+
+        table = Table(title="Ingest Results", show_header=False)
+        table.add_column("Key", style="dim")
+        table.add_column("Value", style="magenta")
+
+        table.add_row("Revision", result.semantic_revision)
+        files_str = (
+            ", ".join(result.deleted_files)
+            if len(result.deleted_files) <= 3
+            else f"{len(result.deleted_files)} files"
+        )
+        table.add_row("Memory", f"[dim]Flushed {files_str} from inbox[/dim]")
+
+        console.print(
+            Panel.fit(
+                table,
+                title=f"[bold magenta]✓ {result.message}[/bold magenta]",
+                border_style="magenta",
+            )
+        )
+
+    except Exception as e:
+        animator.stop(final_status="Semantic ingest failed.")
+        _handle_error(e)
+
+
+@app.command("auth")
+def auth_command() -> None:
+    """Manage authentication and telemetry preferences."""
+    from runtime.cli.auth import manage_auth
+    try:
+        manage_auth()
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+
+if __name__ == "__main__":
+    app()