nova-bridgeye 0.1.0

package/.env.example

@@ -0,0 +1,17 @@
+# NOVA CLI (API-only)
+
+# Where your NOVA_API is running
+NOVA_API_BASE_URL=https://api.nova.bridgeye.com
+
+# Where nova-web auth is running (Render)
+NOVA_AUTH_BASE_URL=https://nova.bridgeye.com
+
+# Optional: debug auth failures locally
+NOVA_DEBUG_AUTH=0
+
+# Optional: defaults for model selector
+NOVA_DEFAULT_PROVIDER=groq
+NOVA_DEFAULT_MODEL=openai/gpt-oss-120b
+
+# Optional: client label (helps logs/audit)
+NOVA_USER_AGENT=NovaCLI/1.0

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:conda",
+    "python-envs.defaultPackageManager": "ms-python.python:conda",
+    "python-envs.pythonProjects": []
+}

package/README.md

@@ -0,0 +1,9 @@
+# NOVA CLI
+
+Official CLI for Bridgeye Nova.
+
+## Installation
+
+### Via pip
+```bash
+pip install bridgeye-nova

package/bin/nova

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# This script calls the python 'nova' command installed via pip
+nova "$@"

package/core/prompts.py

@@ -0,0 +1,158 @@
+import datetime
+import os
+import re
+from nova_cli import config
+from string import Template
+from typing import List, Optional, Dict
+from nova_cli.local.utils import generate_ast_map
+
+# --- CONFIGURATION ---
+EXCLUDED_DIRS = {
+    ".git", "__pycache__", "venv", "env", "node_modules", 
+    ".idea", ".vscode", "dist", "build", ".next", ".ds_store", 
+    ".mypy_cache", ".nova"
+}
+
+_TREE_CACHE = None
+MAX_CONTEXT_CHARS = 150000  # Threshold to trigger skeletal view
+
+def clear_file_tree_cache():
+    global _TREE_CACHE
+    _TREE_CACHE = None
+
+# --- TEMPLATES ---
+SYSTEM_TEMPLATE = Template("""
+/// SYSTEM BOOT SEQUENCE ///
+IDENTITY: N.O.V.A. (Neural Orchestration & Virtual Assistant)
+USER: $user_name (Authorization: Level 10)
+TIME: $current_time
+LOC:  $location
+CWD:  $cwd
+
+/// REPOSITORY MAP (AST) ///
+The following is a high-level map of the codebase structure:
+$dir_structure
+
+/// PERSISTENT CONTEXT ///
+$loaded_files_block
+
+/// ACTIVE CONTEXT ///
+$context_modules
+
+/// PRIME DIRECTIVES ///
+1. [PERSONA & BEHAVIOR]
+   - You are a high-performance Code Engine.
+   - **INPUT CLASSIFICATION**:
+     - **CASUAL/VAGUE**: Respond conversationally.
+     - **TECHNICAL**: Execute immediate file operations.
+   - **STRICT**: No "Certainly sir". Get straight to the point.
+
+2. [SCOPE ADHERENCE]
+   - **DEFAULT LOCATION**: Create files in the **CURRENT DIRECTORY** ($cwd).
+   - **NO HALLUCINATION**: You see only the files listed in PERSISTENT CONTEXT.
+
+3. [WRITE PROTOCOLS - SURGICAL MODE]
+   - **Do NOT rewrite the whole file** when editing.
+   - Use SEARCH/REPLACE blocks.
+   - **COMMAND SYNTAX**:
+     - New Directory: `[MKDIR: path/to/dir]`
+     - New File: `[CREATE: path/to/file.ext]` followed immediately by a **CODE BLOCK**.
+     - Edit File: `[EDIT: path/to/file.ext]` followed by SEARCH/REPLACE blocks.
+     - Delete File/Dir: `[DELETE: path/to/target]`
+   
+   **SEARCH/REPLACE BLOCK FORMAT**:
+   <<<<<<< SEARCH
+   (original code lines - must match EXACTLY)
+   =======
+   (new code lines)
+   >>>>>>> REPLACE
+
+/// INCOMING TRANSMISSION ///
+$user_input
+""")
+
+def get_repo_map_cached(startpath: str) -> str:
+    """
+    Retrieves the AST-based repo map from utils.py, caching the result
+    until clear_file_tree_cache() is called (usually after a file op).
+    """
+    global _TREE_CACHE
+    if _TREE_CACHE is not None: return _TREE_CACHE
+    
+    # Call the new smart mapper in utils
+    result = generate_ast_map(startpath)
+    if not result:
+        result = "[Empty or Non-Python Directory]"
+        
+    _TREE_CACHE = result
+    return result
+
+def generate_skeleton(content: str) -> str:
+    """
+    Minifies file content to save tokens. 
+    Keeps imports, class definitions, and function signatures. 
+    Hides bodies.
+    """
+    lines = content.splitlines()
+    skeleton = []
+    for line in lines:
+        stripped = line.strip()
+        # Keep imports, classes, defs, and decorators
+        if (stripped.startswith("import ") or 
+            stripped.startswith("from ") or 
+            stripped.startswith("class ") or 
+            stripped.startswith("def ") or 
+            stripped.startswith("@")):
+            skeleton.append(line)
+        # Keep non-indented assignments (globals)
+        elif line and not line[0].isspace() and "=" in line:
+            skeleton.append(line)
+            
+    return "\n".join(skeleton) + "\n... [BODY HIDDEN] ..."
+
+def get_loaded_files_block(loaded_files: Dict[str, str], active_file: Optional[str] = None) -> str:
+    """
+    Injects content. 
+    Feature: SMART CONTEXT. 
+    If total size > MAX_CONTEXT_CHARS, minifies files that are NOT the active file.
+    """
+    if not loaded_files:
+        return "[NO FILES LOADED]"
+    
+    # Calculate total size
+    total_size = sum(len(c) for c in loaded_files.values())
+    use_minification = total_size > MAX_CONTEXT_CHARS
+
+    block = []
+    for fname, content in loaded_files.items():
+        # Determine if this file needs to be fully visible
+        is_active = active_file and (fname == active_file or fname == os.path.basename(active_file))
+        
+        if use_minification and not is_active:
+            display_content = generate_skeleton(content)
+            header = f"--- START FILE (OUTLINE): {fname} ---"
+        else:
+            # Full content for active file or small context
+            display_content = content
+            header = f"--- START FILE: {fname} ---"
+
+        block.append(f"{header}\n{display_content}\n--- END FILE: {fname} ---")
+    
+    return "\n\n".join(block)
+
+def get_system_prompt(
+    current_task: Optional[str] = None,
+    loaded_files: Dict[str, str] = {},
+    active_file: Optional[str] = None
+) -> str:
+    """Constructs the dynamic system prompt."""
+    return SYSTEM_TEMPLATE.substitute(
+        user_name=config.USER_NAME,
+        current_time=datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
+        location=config.LOCATION,
+        cwd=os.getcwd(),
+        dir_structure=get_repo_map_cached(os.getcwd()),
+        loaded_files_block=get_loaded_files_block(loaded_files, active_file),
+        context_modules=f"[TASK]: {current_task}" if current_task else "[STANDBY]",
+        user_input="" 
+    ).strip()

package/core/state.py

@@ -0,0 +1,37 @@
+# NOVA_CLI\core\state.py
+
+class SessionState:
+    def __init__(self) -> None:
+        """
+        Initializes the SessionState with default values.
+
+        Attributes:
+            active_file (str | None): The file currently being focused on/edited (absolute path).
+            last_ai_response (str): The last response from the AI.
+            last_generated_code (str | None): The last valid code block generated.
+            loaded_files (dict[str, str]): Canonical mapping {basename: content} for persistent context.
+            loaded_paths (dict[str, str]): Mapping {basename: absolute_path} for writing/applying edits.
+            total_tokens_used (int): The total number of tokens used.
+        """
+        self.active_file: str | None = None
+        self.last_ai_response: str = ""
+        self.last_generated_code: str | None = None
+
+        # Canonical: basename -> content
+        self.loaded_files: dict[str, str] = {}
+
+        # Canonical: basename -> abs path
+        self.loaded_paths: dict[str, str] = {}
+
+        self.total_tokens_used: int = 0
+
+    def reset(self) -> None:
+        """
+        Resets the session state to initial defaults.
+        """
+        self.active_file = None
+        self.last_ai_response = ""
+        self.last_generated_code = None
+        self.loaded_files = {}
+        self.loaded_paths = {}
+        self.total_tokens_used = 0

package/nova_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

package/nova_cli/__main__.py

@@ -0,0 +1,4 @@
+from nova_cli.cli.main import main
+
+if __name__ == "__main__":
+    main()

package/nova_cli/cli/commands.py

@@ -0,0 +1,49 @@
+# NOVA_CLI/nova_cli/cli/commands.py
+
+def register_core_commands(registry, shell):
+    
+    registry.register("login", shell.cmd_login)
+    registry.register("nova login", shell.cmd_login)
+    # model / git
+    registry.register(":model", shell.cmd_model)
+    registry.register(":gitoptions", shell.cmd_gitoptions)
+
+    # reset / unload
+    registry.register(":reset", shell.cmd_reset)
+    registry.register("reset", shell.cmd_reset)
+
+    registry.register(":unload", shell.cmd_unload)
+    registry.register("unload", shell.cmd_unload)
+
+    # map / ls
+    registry.register(":map", shell.cmd_map)
+    registry.register("ls", shell.cmd_map)
+
+    # wizard / apply / paste
+    registry.register(":wizard", shell.cmd_wizard)
+    registry.register(":apply", shell.cmd_apply)
+    registry.register(":paste", shell.cmd_paste)
+
+    # load / navigation
+    registry.register(":load", shell.cmd_load)
+    registry.register("cd", shell.cmd_cd)
+    registry.register("pwd", shell.cmd_pwd)
+
+    # execution / cleanup
+    registry.register("run", shell.cmd_run)
+    registry.register("clean", shell.cmd_clean)
+
+    # build command
+    registry.register("Build It", shell.cmd_build_it)
+    registry.register("build it", shell.cmd_build_it)
+    registry.register("Build", shell.cmd_build_it)
+    registry.register("build", shell.cmd_build_it)
+
+    # exit / help
+    registry.register("exit", shell.cmd_exit)
+    registry.register("quit", shell.cmd_exit)
+
+    registry.register("help", shell.cmd_help)
+    registry.register(":help", shell.cmd_help)
+
+    #registry.register("logout", shell.cmd_logout)  # optional, future-proof

package/nova_cli/cli/main.py

@@ -0,0 +1,83 @@
+import sys
+
+from nova_cli.cli.shell import NovaShell
+from nova_cli.nova_core.ai.api_client import BridgeyeAPIClient
+from nova_cli import config as cli_config
+from nova_cli.nova_core.auth.storage import is_logged_in, has_refresh_token
+
+
+def _doctor() -> int:
+    api = BridgeyeAPIClient()
+
+    print("NOVA CLI — Doctor")
+    print(f"- NOVA_API_BASE_URL:  {cli_config.NOVA_API_BASE_URL}")
+    print(f"- NOVA_AUTH_BASE_URL: {cli_config.NOVA_AUTH_BASE_URL}")
+    print(f"- Default provider:   {cli_config.DEFAULT_PROVIDER}")
+    print(f"- Default model:      {cli_config.DEFAULT_MODEL}")
+
+    api_ok = api.health()
+    print(f"- API reachable:      {'yes' if api_ok else 'no'}")
+
+    logged_in = is_logged_in()
+    print(f"- Logged in:          {'yes' if logged_in else 'no'}")
+
+    # Helpful extra signal: refresh token presence
+    rt = has_refresh_token()
+    print(f"- Has refresh token:  {'yes' if rt else 'no'}")
+
+    if not api_ok:
+        print("\nFix:")
+        print("  1) Start NOVA_API")
+        print("  2) Or set NOVA_API_BASE_URL to the right host/port")
+        return 1
+
+    if not logged_in:
+        print("\nFix:")
+        print("  Run: nova login")
+        return 1
+
+    return 0
+
+
+def main():
+    shell = NovaShell()
+
+    # No args => interactive
+    if len(sys.argv) == 1:
+        shell.run()
+        return
+
+    cmd = sys.argv[1]
+    args = " ".join(sys.argv[2:]) if len(sys.argv) > 2 else ""
+
+    if cmd in ("help", "--help", "-h"):
+        shell.cmd_help("")
+        return
+
+    if cmd == "doctor":
+        raise SystemExit(_doctor())
+
+    if cmd == "run":
+        shell.cmd_run(args)
+        return
+
+    if cmd == "clean":
+        shell.cmd_clean(args)
+        return
+
+    if cmd == "login":
+        shell.cmd_login(args)
+        return
+
+    # Optional legacy alias
+    if cmd == "heal":
+        shell.cmd_run(args)
+        return
+
+    # Anything else => treat as chat prompt (one-shot)
+    prompt = " ".join(sys.argv[1:])
+    shell.handle_ai_request(prompt)
+
+
+if __name__ == "__main__":
+    main()

package/nova_cli/cli/registry.py

@@ -0,0 +1,14 @@
+# NOVA_CLI\nova_cli\cli\registry.py
+
+class CommandRegistry:
+    def __init__(self):
+        self._commands = {}
+
+    def register(self, name, handler):
+        self._commands[name] = handler
+
+    def get(self, name):
+        return self._commands.get(name)
+
+    def all(self):
+        return self._commands