code-context-control 2.28.0__py3-none-any.whl

services/watcher.py

@@ -0,0 +1,192 @@
+"""
+File Watcher Service
+
+Watches project files for changes and tracks modifications:
+- Daemon thread monitors file system events
+- Filters by code extensions, skips node_modules/.git/etc.
+- Accumulates changes for session logging
+- Triggers index rebuild when enough changes accumulate
+"""
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+# Extensions to watch
+CODE_EXTENSIONS = {
+    '.py', '.js', '.ts', '.tsx', '.jsx', '.r', '.R',
+    '.css', '.html', '.json', '.yaml', '.yml', '.md',
+    '.sh', '.sql', '.go', '.rs', '.java', '.cpp', '.c', '.h',
+}
+
+# Directories to skip
+SKIP_DIRS = {
+    'node_modules', '.git', '__pycache__', '.c3', 'venv',
+    'env', '.venv', 'dist', 'build', '.next', '.cache',
+    'coverage', '.pytest_cache',
+}
+
+
+class _ChangeHandler(FileSystemEventHandler):
+    """Collects file change events."""
+
+    def __init__(self):
+        super().__init__()
+        self._lock = threading.Lock()
+        self._changes = []
+
+    def _should_track(self, path: str) -> bool:
+        p = Path(path)
+        if any(skip in p.parts for skip in SKIP_DIRS):
+            return False
+        return p.suffix.lower() in CODE_EXTENSIONS
+
+    def _record(self, event_type: str, path: str):
+        if not self._should_track(path):
+            return
+        with self._lock:
+            self._changes.append({
+                "type": event_type,
+                "path": path,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            })
+
+    def on_modified(self, event):
+        if not event.is_directory:
+            self._record("modified", event.src_path)
+
+    def on_created(self, event):
+        if not event.is_directory:
+            self._record("created", event.src_path)
+
+    def on_deleted(self, event):
+        if not event.is_directory:
+            self._record("deleted", event.src_path)
+
+    def on_moved(self, event):
+        if not event.is_directory:
+            self._record("moved", event.src_path)
+
+    def get_and_clear(self) -> list:
+        with self._lock:
+            changes = list(self._changes)
+            self._changes.clear()
+            return changes
+
+    @property
+    def change_count(self) -> int:
+        with self._lock:
+            return len(self._changes)
+
+
+class CodeWatcher:
+    """Watches project files for changes on a daemon thread."""
+
+    def __init__(self, project_path: str):
+        self.project_path = str(Path(project_path).resolve())
+        self._handler = _ChangeHandler()
+        self._observer = Observer()
+        self._observer.daemon = True
+        self._file_memory = None
+        self._compressor = None
+        self._worker_thread = None
+        self._stop_event = threading.Event()
+        self._update_queue = set()
+        self._queue_lock = threading.Lock()
+
+    def set_backends(self, file_memory, compressor, validation_cache=None):
+        """Set backends for proactive background updates."""
+        self._file_memory = file_memory
+        self._compressor = compressor
+        self._validation_cache = validation_cache
+
+    def _background_worker(self):
+        import time
+        from pathlib import Path
+        # Debounce tracking: {abs_path: last_enqueue_time}
+        pending_validation: dict[str, float] = {}
+        while not self._stop_event.is_set():
+            time.sleep(1.0)
+            now = time.time()
+            paths_to_update = []
+            with self._queue_lock:
+                if self._update_queue:
+                    paths_to_update = list(self._update_queue)
+                    self._update_queue.clear()
+
+            for path in paths_to_update:
+                if self._stop_event.is_set():
+                    break
+                try:
+                    rel_path = str(Path(path).resolve().relative_to(self.project_path))
+                    # Pre-emptively update structural map
+                    if self._file_memory:
+                        self._file_memory.update(rel_path)
+                    # Pre-emptively compress
+                    if self._compressor:
+                        self._compressor.compress_file(str(Path(path)), "smart")
+                except Exception:
+                    pass
+                # Track for debounced validation
+                if self._validation_cache:
+                    pending_validation[path] = now
+
+            # Run debounced validation for files that haven't changed recently
+            if self._validation_cache and pending_validation:
+                debounce = self._validation_cache.debounce_seconds
+                ready = [p for p, t in pending_validation.items() if now - t >= debounce]
+                for path in ready:
+                    if self._stop_event.is_set():
+                        break
+                    pending_validation.pop(path, None)
+                    try:
+                        rel_path = str(Path(path).resolve().relative_to(self.project_path))
+                        self._validation_cache.validate_file(rel_path)
+                    except Exception:
+                        pass
+
+    def start(self):
+        """Start watching (non-blocking, daemon thread)."""
+        self._observer.schedule(self._handler, self.project_path, recursive=True)
+        self._observer.start()
+
+        # Start background worker for proactive mapping
+        self._worker_thread = threading.Thread(target=self._background_worker, daemon=True)
+        self._worker_thread.start()
+
+    def stop(self):
+        """Stop watching."""
+        self._stop_event.set()
+        self._observer.stop()
+        self._observer.join(timeout=2)
+        if self._worker_thread:
+            self._worker_thread.join(timeout=2)
+
+    def get_changes(self) -> list:
+        """Return accumulated changes and clear the buffer."""
+        changes = self._handler.get_and_clear()
+
+        # Enqueue modified files for background update
+        with self._queue_lock:
+            for c in changes:
+                if c["type"] in ("modified", "created"):
+                    self._update_queue.add(c["path"])
+                elif c["type"] == "deleted" and self._validation_cache:
+                    try:
+                        rel = str(Path(c["path"]).resolve().relative_to(self.project_path))
+                        self._validation_cache.evict(rel)
+                    except Exception:
+                        pass
+
+        return changes
+
+    def rebuild_if_needed(self, indexer, threshold: int = 10) -> dict | None:
+        """Trigger index rebuild if enough changes have accumulated."""
+        if self._handler.change_count >= threshold:
+            changes = self.get_changes()
+            result = indexer.build_index()
+            result["triggered_by_changes"] = len(changes)
+            return result
+        return None

tui/backend.py

@@ -0,0 +1,59 @@
+import asyncio
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_c3_path():
+    # Resolves to the root directory's cli/c3.py
+    current_dir = Path(__file__).resolve().parent
+    root_dir = current_dir.parent
+    c3_path = root_dir / "cli" / "c3.py"
+    return str(c3_path), str(root_dir)
+async def run_cmd_async(*args):
+    """Runs a c3 command asynchronously and returns stdout."""
+    c3_path, root_dir = get_c3_path()
+
+    env = os.environ.copy()
+    env["PYTHONPATH"] = root_dir
+
+    cmd = [sys.executable, c3_path] + list(args)
+
+    kwargs = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        env=env,
+        **kwargs
+    )
+
+    stdout, _ = await process.communicate()
+    return stdout.decode("utf-8", errors="replace")
+
+def run_cmd(*args):
+    """Runs a c3 command synchronously."""
+    c3_path, root_dir = get_c3_path()
+
+    env = os.environ.copy()
+    env["PYTHONPATH"] = root_dir
+
+    cmd = [sys.executable, c3_path] + list(args)
+
+    kwargs = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+
+    result = subprocess.run(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        env=env,
+        text=True,
+        **kwargs
+    )
+    return result.stdout

tui/main.py

@@ -0,0 +1,145 @@
+import os
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import Button, Footer, Header, Label, ListItem, ListView
+
+
+class SidebarItem(ListItem):
+    def __init__(self, label: str, view_id: str, **kwargs):
+        super().__init__(**kwargs)
+        self.label = label
+        self.view_id = view_id
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.label)
+
+class C3App(App):
+    CSS_PATH = "theme.tcss"
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("tab", "toggle_focus", "Focus: NAV/CONTENT", show=True),
+        Binding("ctrl+t", "toggle_theme", "Theme", show=True),
+    ]
+
+    def compose(self) -> ComposeResult:
+        from screens.stats import StatsWidget
+        yield Header(show_clock=True)
+        with Horizontal():
+            with Vertical(id="sidebar"):
+                yield ListView(
+                    SidebarItem("Projects", "projects"),
+                    SidebarItem("Index", "index"),
+                    SidebarItem("Search", "search"),
+                    SidebarItem("Compress", "compress"),
+                    SidebarItem("Session", "session"),
+                    SidebarItem("ClaudeMD", "claudemd"),
+                    SidebarItem("Pipe", "pipe"),
+                    SidebarItem("Optimize", "optimize"),
+                    SidebarItem("Init", "init"),
+                    SidebarItem("MCP", "mcp"),
+                    SidebarItem("Benchmark", "benchmark"),
+                    SidebarItem("Web UI", "web_ui"),
+                    id="nav_list"
+                )
+            with Container(id="content"):
+                pass
+            with Vertical(id="right-sidebar"):
+                yield StatsWidget()
+                yield Button("Theme: Dark", id="theme_toggle_btn", classes="quick-btn")
+        yield Footer()
+        yield Label(f" {os.getcwd()} ", id="cwd_label")
+
+    def on_mount(self) -> None:
+        self.title = "C3 COMPANION"
+        self.sub_title = "v2.28.0 (Textual)"
+        self.theme_mode = "dark"
+        self.screen.add_class("theme-dark")
+        self._sync_theme_button()
+
+        # Open Projects hub by default
+        nav_list = self.query_one("#nav_list", ListView)
+        nav_list.index = 0
+        self.mount_view("projects", "Projects")
+        self.action_toggle_focus()
+
+    def action_toggle_focus(self) -> None:
+        nav_list = self.query_one("#nav_list")
+        if self.focused == nav_list:
+            self.query_one("#content").focus()
+        else:
+            nav_list.focus()
+
+    def action_toggle_theme(self) -> None:
+        if self.theme_mode == "dark":
+            self.theme_mode = "light"
+            self.screen.remove_class("theme-dark")
+            self.screen.add_class("theme-light")
+        else:
+            self.theme_mode = "dark"
+            self.screen.remove_class("theme-light")
+            self.screen.add_class("theme-dark")
+        self._sync_theme_button()
+        self.notify(f"{self.theme_mode.title()} mode enabled", timeout=1.5)
+
+    def _sync_theme_button(self) -> None:
+        self.query_one("#theme_toggle_btn", Button).label = (
+            f"Theme: {self.theme_mode.title()}"
+        )
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        item = event.item
+        if isinstance(item, SidebarItem):
+            self.mount_view(item.view_id, item.label)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "theme_toggle_btn":
+            self.action_toggle_theme()
+
+    def mount_view(self, view_id: str, label: str) -> None:
+        content_container = self.query_one("#content")
+        # Remove existing view
+        content_container.query("*").remove()
+
+        # Mount new view
+        if view_id == "projects":
+            from screens.projects_view import ProjectsView
+            content_container.mount(ProjectsView())
+        elif view_id == "index":
+            from screens.index_view import IndexWidget
+            content_container.mount(IndexWidget())
+        elif view_id == "search":
+            from screens.search_view import SearchView
+            content_container.mount(SearchView())
+        elif view_id == "compress":
+            from screens.compress_view import CompressView
+            content_container.mount(CompressView())
+        elif view_id == "session":
+            from screens.session_view import SessionView
+            content_container.mount(SessionView())
+        elif view_id == "claudemd":
+            from screens.claudemd_view import ClaudeMDView
+            content_container.mount(ClaudeMDView())
+        elif view_id == "pipe":
+            from screens.pipe_view import PipeView
+            content_container.mount(PipeView())
+        elif view_id == "optimize":
+            from screens.optimize_view import OptimizeView
+            content_container.mount(OptimizeView())
+        elif view_id == "init":
+            from screens.init_view import InitView
+            content_container.mount(InitView())
+        elif view_id == "mcp":
+            from screens.mcp_view import MCPView
+            content_container.mount(MCPView())
+        elif view_id == "benchmark":
+            from screens.benchmark_view import BenchmarkView
+            content_container.mount(BenchmarkView())
+        elif view_id == "web_ui":
+            from screens.ui_view import UIView
+            content_container.mount(UIView())
+
+if __name__ == "__main__":
+    app = C3App()
+    app.run()

tui/screens/__init__.py

@@ -0,0 +1 @@
+# Package init

tui/screens/benchmark_view.py

@@ -0,0 +1,109 @@
+import asyncio
+import os
+import sys
+
+from backend import get_c3_path
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Checkbox, Input, Label, Log
+
+
+class BenchmarkView(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Benchmark Configuration", ""):
+            yield Label("Runs a series of tests to measure C3 performance.", classes="card-title")
+            with Horizontal(classes="input-row"):
+                yield Label("Path:", classes="input-label")
+                yield Input(".", id="project_path")
+                yield Label("Sample Size:", classes="input-label")
+                yield Input("50", placeholder="e.g. 50", id="sample_size")
+
+            with Horizontal(classes="input-row"):
+                yield Label("Min Tokens:", classes="input-label")
+                yield Input("100", placeholder="e.g. 100", id="min_tokens")
+                yield Label("Top K:", classes="input-label")
+                yield Input("5", placeholder="e.g. 5", id="top_k")
+
+            with Horizontal(classes="input-row"):
+                yield Label("Max Tokens:", classes="input-label")
+                yield Input("10000", placeholder="e.g. 10000", id="max_tokens")
+                yield Label("System Name:", classes="input-label")
+                yield Input("c3", placeholder="e.g. codex", id="sys_name")
+
+            with Horizontal(classes="input-row"):
+                yield Label("Sys Label:", classes="input-label")
+                yield Input(placeholder="e.g. OpenAI", id="sys_label")
+                yield Label("Sys Version:", classes="input-label")
+                yield Input(placeholder="e.g. v1.0", id="sys_version")
+
+            with Horizontal(classes="input-row"):
+                yield Label("JSON Out:", classes="input-label")
+                yield Input(placeholder="out.json", id="out_json")
+                yield Label("HTML Out:", classes="input-label")
+                yield Input(placeholder="report.html", id="out_html")
+
+            with Horizontal(classes="action-row"):
+                yield Checkbox("Print JSON", id="json_check")
+                yield Checkbox("No HTML", id="no_html_check")
+                yield Button("Start Benchmark", id="run_btn", variant="primary")
+
+        with Card("Results", ""):
+            yield Log(id="output_log", highlight=True)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "run_btn":
+            self.query_one("#output_log").clear()
+            self.query_one("#run_btn").disabled = True
+
+            # Gather all kwargs
+            args = []
+
+            # Options with values
+            val_map = {
+                "--sample-size": "sample_size",
+                "--min-tokens": "min_tokens",
+                "--top-k": "top_k",
+                "--max-tokens": "max_tokens",
+                "--system-name": "sys_name",
+                "--system-label": "sys_label",
+                "--system-version": "sys_version",
+                "--output": "out_json",
+                "--html-output": "out_html"
+            }
+
+            for flag, widget_id in val_map.items():
+                val = self.query_one(f"#{widget_id}").value
+                if val:
+                    args.extend([flag, val])
+
+            # Flags
+            if self.query_one("#json_check").value:
+                args.append("--json")
+            if self.query_one("#no_html_check").value:
+                args.append("--no-html")
+
+            # Positional path
+            path = self.query_one("#project_path").value
+            if path:
+                args.append(path)
+
+            self.run_benchmark(args)
+
+    @work(exclusive=True)
+    async def run_benchmark(self, args: list) -> None:
+        c3_path, root_dir = get_c3_path()
+        cmd = [sys.executable, c3_path, "benchmark"] + args
+        env = os.environ.copy()
+        env["PYTHONPATH"] = root_dir
+
+        process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, env=env)
+        log_widget = self.query_one("#output_log")
+        while True:
+            line = await process.stdout.readline()
+            if not line: break
+            log_widget.write_line(line.decode(errors="replace").rstrip())
+        await process.wait()
+
+        self.query_one("#run_btn").disabled = False

tui/screens/claudemd_view.py

@@ -0,0 +1,46 @@
+import asyncio
+import os
+import sys
+
+from backend import get_c3_path
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Label, Log
+
+
+class ClaudeMDView(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Documentation Generator", ""):
+            yield Label("Generates or updates CLAUDE.md / GEMINI.md instructions.")
+            with Horizontal(classes="action-row"):
+                yield Button("Generate CLAUDE.md", id="gen_btn", variant="primary")
+                yield Button("Check Health", id="check_btn")
+
+        with Card("Process Output", ""):
+            yield Log(id="output_log", highlight=True)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        log = self.query_one("#output_log")
+        log.clear()
+
+        if event.button.id == "gen_btn":
+            self.run_task("claudemd", "generate")
+        elif event.button.id == "check_btn":
+            self.run_task("claudemd", "check")
+
+    @work(exclusive=True)
+    async def run_task(self, *args) -> None:
+        c3_path, root_dir = get_c3_path()
+        cmd = [sys.executable, c3_path] + list(args)
+        env = os.environ.copy()
+        env["PYTHONPATH"] = root_dir
+
+        process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, env=env)
+        log_widget = self.query_one("#output_log")
+        while True:
+            line = await process.stdout.readline()
+            if not line: break
+            log_widget.write_line(line.decode(errors="replace").rstrip())
+        await process.wait()

tui/screens/compress_view.py

@@ -0,0 +1,52 @@
+import asyncio
+import os
+import sys
+
+from backend import get_c3_path
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Input, Label, Log, Select
+
+
+class CompressView(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Token Efficiency", ""):
+            with Horizontal(classes="input-row"):
+                yield Label("File Path: ", classes="input-label")
+                yield Input(placeholder="path/to/file.py", id="file_input")
+            with Horizontal(classes="input-row"):
+                yield Label("Mode: ", classes="input-label")
+                yield Select([("Smart", "smart"), ("Map", "map"), ("Dense Map", "dense_map"), ("Diff", "diff")], value="smart", id="mode_select")
+            with Horizontal(classes="action-row"):
+                yield Button("Compress File", id="run_btn", variant="primary")
+
+        with Card("Compressed Output", ""):
+            yield Log(id="output_log", highlight=True)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "run_btn":
+            path = self.query_one("#file_input").value
+            mode = self.query_one("#mode_select").value
+            if not path: return
+
+            self.query_one("#output_log").clear()
+            self.query_one("#run_btn").disabled = True
+            self.run_compress(path, mode)
+
+    @work(exclusive=True)
+    async def run_compress(self, path: str, mode: str) -> None:
+        c3_path, root_dir = get_c3_path()
+        cmd = [sys.executable, c3_path, "compress", path, "--mode", mode]
+        env = os.environ.copy()
+        env["PYTHONPATH"] = root_dir
+
+        process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, env=env)
+        log_widget = self.query_one("#output_log")
+        while True:
+            line = await process.stdout.readline()
+            if not line: break
+            log_widget.write_line(line.decode(errors="replace").rstrip())
+        await process.wait()
+        self.query_one("#run_btn").disabled = False

tui/screens/index_view.py

@@ -0,0 +1,74 @@
+import asyncio
+import os
+import sys
+
+from backend import get_c3_path
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Input, Label, Log
+
+
+class IndexWidget(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Configuration", ""):
+            with Horizontal(id="index-config-row"):
+                yield Label("Max Files to Index: ", classes="input-label")
+                yield Input("500", placeholder="500", id="max_files_input")
+            with Horizontal(id="index-actions-row"):
+                yield Button("Start Indexing", id="start_btn", variant="primary")
+                yield Button("Stop", id="stop_btn", variant="error")
+
+        with Card("Status Output", ""):
+            yield Log(id="index_log", highlight=True)
+
+    def on_mount(self) -> None:
+        self.process = None
+        self.query_one("#stop_btn").disabled = True
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "start_btn":
+            max_files = self.query_one("#max_files_input").value or "500"
+            self.query_one("#index_log").clear()
+            self.query_one("#index_log").write_line(f"Starting indexer with max files: {max_files}...")
+            self.query_one("#start_btn").disabled = True
+            self.query_one("#stop_btn").disabled = False
+            self.run_indexer(max_files)
+        elif event.button.id == "stop_btn":
+            if self.process:
+                self.process.terminate()
+            self.query_one("#start_btn").disabled = False
+            self.query_one("#stop_btn").disabled = True
+            self.query_one("#index_log").write_line("[bold red]Indexing stopped by user.[/]")
+
+    @work(exclusive=True, thread=False)
+    async def run_indexer(self, max_files: str) -> None:
+        c3_path, root_dir = get_c3_path()
+        env = os.environ.copy()
+        env["PYTHONPATH"] = root_dir
+
+        cmd = [sys.executable, c3_path, "index", "--max-files", max_files]
+        self.process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env=env
+        )
+
+        log_widget = self.query_one("#index_log")
+
+        while True:
+            line = await self.process.stdout.readline()
+            if not line:
+                break
+            log_widget.write_line(line.decode(errors="replace").rstrip())
+
+        await self.process.wait()
+
+        # Only update if not already stopped/reset by the Stop button
+        if self.process is not None:
+            self.query_one("#start_btn").disabled = False
+            self.query_one("#stop_btn").disabled = True
+            log_widget.write_line("[bold green]Indexing completed.[/]")
+            self.process = None