opalacoder 0.1.0__py3-none-any.whl

opalacoder/cli.py

@@ -0,0 +1,339 @@
+"""OpalaCoder CLI – entry point."""
+
+import asyncio
+import argparse
+import os
+import sys
+
+from . import __version__
+from .config import DEFAULT_MODEL, ALTERNATIVE_MODEL, DEFAULT_MAX_RETRIES, DEFAULT_MODE, DEFAULT_DB_PATH, DEFAULT_LANG
+from .project import ProjectStore, ProjectData
+from .agents import make_chat_memgpt_agent, make_intent_classifier, make_complexity_evaluator
+from .api_keys import ensure_api_key
+from . import terminal as T
+from agenticblocks.blocks.llm.agent import AgentInput
+from .i18n import _, set_lang
+from rich.markup import escape as _escape
+from .cli_commands import REPLState, _registry
+
+
+def _inject_project(project: ProjectData, prompt: str) -> str:
+    """Prepend project context to every prompt sent to agents."""
+    return project.context_header() + prompt
+
+
+# ─── Project startup menu ─────────────────────────────────────────────────────
+
+async def startup_menu(store: ProjectStore, args) -> ProjectData:
+    """Show the project selection/creation menu and return a ready ProjectData."""
+    projects = store.list_projects()
+
+    if projects:
+        options = ["Create new project"] + [
+            f"{p['project_name'] or p['name']}  [{p['project_path']}]"
+            for p in projects
+        ]
+        choice = T.choose("What would you like to do?", options[:4] if len(options) > 4 else options)
+        if choice == "Create new project":
+            return await _create_project(store, args)
+        else:
+            idx = options.index(choice) - 1
+            name = projects[idx]["name"]
+            project = store.load(name)
+            project.mode = args.mode
+            project.model = args.model
+            store.save(project)
+            T.success(f"Project '{project.project_name or project.name}' loaded.")
+            return project
+    else:
+        T.info("No projects found. Let's create your first one.")
+        return await _create_project(store, args)
+
+
+async def _create_project(store: ProjectStore, args) -> ProjectData:
+    """Interactively create a new project and select its skills via LLM."""
+    from .skills import select_skills_for_project, load_skills
+
+    project_name = T.ask("Project name").strip() or "default"
+    cwd = os.getcwd()
+    entered_path = T.ask(f"Project path [{cwd}]").strip()
+    project_path = os.path.abspath(entered_path if entered_path else cwd)
+
+    if not os.path.exists(project_path):
+        os.makedirs(project_path, exist_ok=True)
+        T.success(f"Directory created: {project_path}")
+
+    description = T.ask("Brief project description (used to select skills)").strip()
+
+    all_skills = load_skills(project_path)
+    available = [s["name"] for s in all_skills if s["name"] != "opalacoder"]
+    T.info(f"Available skills: opalacoder (default), {', '.join(available) if available else '(none)'}")
+
+    if description and available:
+        with T.spinner(_("selecting_skills")):
+            chosen_skills = await select_skills_for_project(args.model, description, project_path)
+    else:
+        chosen_skills = ["opalacoder"]
+
+    T.success(f"Skills selected: {', '.join(chosen_skills)}")
+
+    db_key = project_name.replace(" ", "_").lower()
+    if store.exists(db_key):
+        db_key = db_key + "_1"
+
+    project = store.create(
+        name=db_key,
+        mode=args.mode,
+        model=args.model,
+        project_name=project_name,
+        project_path=project_path,
+        skills=chosen_skills,
+        description=description,
+    )
+    T.success(f"Project '{project_name}' created.")
+    return project
+
+
+# ─── REPL Loop ────────────────────────────────────────────────────────────────
+
+async def repl_loop(project: ProjectData, store: ProjectStore, max_retries: int) -> None:
+    from .tools import set_project_path
+    from .skills import load_project_skills
+
+    set_project_path(project.project_path)
+    project_skills = load_project_skills(project.project_path, project.skills)
+
+    T.section(f"Active Project: {_escape(project.project_name or project.name)}")
+    T.console.print(f"  [dim]Path:   {_escape(project.project_path)}[/dim]")
+    T.console.print(f"  [dim]Skills: {', '.join(project.skills)}[/dim]")
+
+    chat_agent = make_chat_memgpt_agent(project.model)
+    state = REPLState(project, store, project_skills, chat_agent)
+
+    if state.project.request and state.project.plan_text and not state.project.results:
+        T.warning(_("pending_demand", request=state.project.request[:50]))
+        choice = T.choose(_("resume_or_clear"), [_("resume"), _("clear")])
+        if choice == _("resume"):
+            await run_pipeline(state.project, store, max_retries, project_skills=state.project_skills)
+        else:
+            state.project.clear_state()
+            store.save(state.project)
+
+    while True:
+        try:
+            user_input = T.ask(f"OpalaCoder ({state.display_name})")
+            if not user_input:
+                continue
+
+            if user_input.startswith("/"):
+                cmd, *args = user_input.split(maxsplit=1)
+                if cmd not in _registry:
+                    T.error(_("unknown_command", cmd=cmd))
+                    continue
+                result = await _registry.dispatch(state, cmd, args)
+                if result == "break":
+                    break
+                elif result == "continue":
+                    continue
+
+            else:
+                _VALID_INTENTS = {"greetings", "question", "plan", "chat", "command_hint"}
+                classifier = make_intent_classifier(state.project.model)
+                with T.spinner(_("agent_thinking")):
+                    intent_res = await classifier.run(AgentInput(prompt=user_input))
+                    _raw = intent_res.response.strip().lower()
+                    intent = _raw.split()[0].rstrip(".,!?") if _raw else ""
+
+
+                if not intent or intent not in _VALID_INTENTS:
+                    T.console.print(f"[yellow]{_('intent_unclear')}[/yellow]")
+                    continue
+
+                if intent == "command_hint":
+                    cmd_word = user_input.strip().split()[0].lower()
+                    T.console.print(f"[yellow]{_('command_hint_suggestion', cmd=cmd_word)}[/yellow]")
+                    continue
+
+                if intent == "plan":
+                    if state.project.results or state.project.request:
+                        state.project.clear_state()
+                        store.save(state.project)
+
+                    if state.project.model.startswith("ollama/"):
+                        complexity = "alternative" if len(user_input.split()) > 200 else "default"
+                    else:
+                        complexity_evaluator = make_complexity_evaluator(state.project.model)
+                        with T.spinner(_("evaluating_complexity")):
+                            comp_res = await complexity_evaluator.run(AgentInput(prompt=user_input))
+                            raw_comp = comp_res.response.strip().lower()
+                            if "alternative" in raw_comp:
+                                complexity = "alternative"
+                            else:
+                                complexity = "default"
+
+                    if complexity == "alternative":
+                        if ensure_api_key(ALTERNATIVE_MODEL):
+                            T.info(_("routing_complex_task", model=ALTERNATIVE_MODEL))
+                            active_model = ALTERNATIVE_MODEL
+                        else:
+                            T.warning(_("api_key_missing_fallback", model=state.project.model))
+                            active_model = state.project.model
+                    else:
+                        active_model = state.project.model
+
+                    try:
+                        await run_pipeline(state.project, store, max_retries, request=user_input, active_model=active_model, project_skills=state.project_skills)
+                    except Exception as e:
+                        if active_model != state.project.model:
+                            T.error(_("alt_model_error", model=active_model, err=e))
+                            T.info(_("fallback_to_model", model=state.project.model))
+                            if state.project.results or state.project.request:
+                                state.project.clear_state()
+                                store.save(state.project)
+                            await run_pipeline(state.project, store, max_retries, request=user_input, active_model=state.project.model, project_skills=state.project_skills)
+                        else:
+                            raise
+                else:
+                    with T.spinner(_("agent_thinking")):
+                        response = await state.chat_agent.run(AgentInput(prompt=_inject_project(state.project, user_input)))
+                    answer = response.response.strip() if response.response else "(no response)"
+                    T.console.print(f"\n[bold green]OpalaCoder:[/bold green] {answer}\n")
+                    store.append_message(state.project, "user", user_input)
+                    store.append_message(state.project, "assistant", answer)
+
+        except KeyboardInterrupt:
+            T.info(_("repl_interrupted"))
+            break
+        except EOFError:
+            T.info(_("exiting"))
+            break
+        except T.UserCancelled:
+            T.info(_("repl_cancelled"))
+            state.project.clear_state()
+            store.save(state.project)
+        except T.AppExit:
+            T.info(_("exiting"))
+            break
+        except Exception as e:
+            T.error(_("unexpected_error", err=e))
+
+
+async def run_pipeline(
+    project: ProjectData,
+    store: ProjectStore,
+    max_retries: int,
+    request: str = None,
+    active_model: str = None,
+    project_skills: list = None,
+) -> None:
+    model = active_model or project.model
+    T.info(_("using_model", model=model))
+
+    if not request:
+        return
+
+    T.section(_("new_demand"))
+    store.append_message(project, "user", request)
+    project.request = request
+    store.save(project)
+
+    hist_text = ""
+    for msg in project.history[-10:-1]:
+        role = "Assistant" if msg["role"] == "assistant" else "User"
+        hist_text += f"{role}: {msg['content']}\n"
+
+    from .orchestrator import AutonomousOrchestratorStrategy
+    from .skills import get_relevant_skills_llm, SCOPE_ORCHESTRATOR
+
+    orchestrator_skills = await get_relevant_skills_llm(
+        model, request, scope=SCOPE_ORCHESTRATOR, project_skills=project_skills
+    )
+    enriched_request = request
+    if orchestrator_skills:
+        enriched_request = (
+            f"[SKILLS CONTEXT]:\n{orchestrator_skills}\n[END SKILLS CONTEXT]\n\n"
+            f"[USER REQUEST]:\n{request}\n[END USER REQUEST]"
+        )
+
+    orchestrator = AutonomousOrchestratorStrategy(model=model)
+
+    final_response = await orchestrator.run(
+        user_request=enriched_request,
+        history=hist_text,
+        session=project,
+        store=store,
+        max_retries=max_retries,
+    )
+
+    T.section(_("phase5"))
+
+    store.append_message(project, "assistant", final_response)
+    T.show_result(final_response)
+    project.clear_state()
+    store.save(project)
+
+
+# ─── CLI entrypoint ───────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="opalacoder",
+        description="OpalaCoder – project-centric coding agent",
+    )
+    parser.add_argument("--version", action="version", version=f"OpalaCoder {__version__}")
+    parser.add_argument("--mode", choices=["auto", "plan", "edit"], default=DEFAULT_MODE)
+    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"LLM model (default: {DEFAULT_MODEL})")
+    parser.add_argument("--max-retries", type=int, default=DEFAULT_MAX_RETRIES)
+    parser.add_argument("--db", default=DEFAULT_DB_PATH)
+    parser.add_argument("--lang", choices=["en", "pt"], default=DEFAULT_LANG)
+    parser.add_argument("--delete", metavar="PROJECT_NAME", help="Delete a project and exit")
+    parser.add_argument("--list-projects", action="store_true", help="List all projects and exit")
+    parser.add_argument("--debug", action="store_true")
+    return parser
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.debug:
+        from opalacoder.config import setup_litellm_debug
+        setup_litellm_debug()
+
+    set_lang(args.lang)
+    T.print_banner(version=__version__, mode=args.mode)
+
+    store = ProjectStore(db_path=args.db)
+
+    if args.list_projects:
+        projects = store.list_projects()
+        if not projects:
+            T.info("No projects found.")
+        else:
+            T.section("Existing Projects")
+            for p in projects:
+                pname = p["project_name"] or p["name"]
+                T.console.print(
+                    f"  [cyan]{_escape(p['name'])}[/cyan]  [bold]{_escape(pname)}[/bold]  "
+                    f"[dim]{_escape(p['project_path'])}  {p['updated_at'][:10]}[/dim]"
+                )
+        sys.exit(0)
+
+    if args.delete:
+        if store.exists(args.delete):
+            store.delete(args.delete)
+            T.success(f"Project '{args.delete}' deleted.")
+        else:
+            T.error(f"Project '{args.delete}' not found.")
+        sys.exit(0)
+
+    try:
+        project = asyncio.run(startup_menu(store, args))
+        asyncio.run(repl_loop(project, store, max_retries=args.max_retries))
+    except KeyboardInterrupt:
+        T.warning(_("repl_interrupted"))
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

opalacoder/cli_commands.py

@@ -0,0 +1,277 @@
+"""REPL command registry and handlers for OpalaCoder CLI."""
+
+from .project import ProjectStore, ProjectData
+from .agents import make_chat_memgpt_agent
+from . import terminal as T
+from .i18n import _
+from rich.markup import escape as _escape
+
+
+# ─── REPL state container ─────────────────────────────────────────────────────
+
+class REPLState:
+    def __init__(self, project: ProjectData, store: ProjectStore, project_skills: list, chat_agent):
+        self.project = project
+        self.store = store
+        self.project_skills = project_skills
+        self.chat_agent = chat_agent
+
+    @property
+    def display_name(self) -> str:
+        return self.project.project_name or self.project.name
+
+
+# ─── Command registry ─────────────────────────────────────────────────────────
+
+class CommandRegistry:
+    def __init__(self):
+        self._cmds: dict[str, tuple] = {}
+
+    def register(self, *names: str, usage: str = "", description: str = ""):
+        def decorator(fn):
+            for name in names:
+                self._cmds[name] = (fn, usage, description)
+            return fn
+        return decorator
+
+    def __contains__(self, cmd: str) -> bool:
+        return cmd in self._cmds
+
+    def help_lines(self) -> list[tuple[str, str]]:
+        seen, result = set(), []
+        for name, (fn, usage, desc) in self._cmds.items():
+            if fn not in seen:
+                seen.add(fn)
+                result.append((f"{name} {usage}".strip(), desc))
+        return result
+
+    async def dispatch(self, state: REPLState, cmd: str, args: list[str]) -> str | None:
+        fn, _, _ = self._cmds[cmd]
+        return await fn(state, args)
+
+
+_registry = CommandRegistry()
+
+
+# ─── Command handlers ─────────────────────────────────────────────────────────
+
+@_registry.register("/help", "/h", description="Show this help message")
+async def cmd_help(_state: REPLState, _args: list[str]) -> None:
+    T.console.print(f"\n[cyan]{_('available_commands')}[/cyan]")
+    for display, desc in _registry.help_lines():
+        T.console.print(f"  [green]{display:<28}[/green] {desc}")
+    T.console.print()
+
+
+@_registry.register("/clear", description="Clear project memory and history")
+async def cmd_clear(state: REPLState, _args: list[str]) -> None:
+    from .skills import load_project_skills
+    if T.confirm("Are you sure you want to clear this project's memory?"):
+        state.project = state.store.overwrite(
+            state.project.name, state.project.mode, state.project.model,
+            state.project.project_name, state.project.project_path,
+            state.project.skills, state.project.description,
+        )
+        state.project_skills = load_project_skills(state.project.project_path, state.project.skills)
+        state.chat_agent = make_chat_memgpt_agent(state.project.model)
+        T.success("Project memory cleared.")
+
+
+@_registry.register("/rename", usage="<new_name>", description="Rename the current project")
+async def cmd_rename(state: REPLState, args: list[str]) -> str | None:
+    if not args:
+        T.error("Usage: /rename <new_name>")
+        return "continue"
+    new_name = args[0].strip('"\'')
+    if state.store.rename(state.project.name, new_name):
+        state.project.name = new_name
+        state.store.save(state.project)
+        T.success(f"Project renamed to '{new_name}'.")
+    else:
+        T.error(f"A project named '{new_name}' already exists.")
+
+
+@_registry.register("/list", description="List all projects")
+async def cmd_list(state: REPLState, _args: list[str]) -> None:
+    projects = state.store.list_projects()
+    if not projects:
+        T.info("No projects found.")
+    else:
+        T.console.print(f"\n[dim]Existing projects:[/dim]")
+        for p in projects:
+            pname = p["project_name"] or p["name"]
+            T.console.print(
+                f"  [cyan]{_escape(p['name'])}[/cyan]  "
+                f"[bold]{_escape(pname)}[/bold]  "
+                f"[dim]{_escape(p['project_path'])}  {p['updated_at'][:10]}  mode={p['mode']}[/dim]"
+            )
+        T.console.print()
+
+
+@_registry.register("/load", usage="<name>", description="Load another project")
+async def cmd_load(state: REPLState, args: list[str]) -> str | None:
+    from .tools import set_project_path
+    from .skills import load_project_skills
+    if not args:
+        T.error("Usage: /load <name>")
+        return "continue"
+    name = args[0].strip('"\'')
+    if not state.store.exists(name):
+        T.error(f"Project '{name}' not found.")
+        return "continue"
+    loaded = state.store.load(name)
+    if loaded:
+        state.project = loaded
+        set_project_path(state.project.project_path)
+        state.project_skills = load_project_skills(state.project.project_path, state.project.skills)
+        state.chat_agent = make_chat_memgpt_agent(state.project.model)
+        T.success(f"Project '{name}' loaded.")
+        T.console.print(f"  [dim]Skills: {', '.join(state.project.skills)}[/dim]")
+        if state.project.request and state.project.plan_text and not state.project.results:
+            T.warning(_("pending_demand", request=state.project.request[:50]))
+    else:
+        T.error(f"Project '{name}' not found.")
+
+
+@_registry.register("/delete", usage="<name>", description="Delete a project")
+async def cmd_delete(state: REPLState, args: list[str]) -> str | None:
+    if not args:
+        T.error("Usage: /delete <name>")
+        return "continue"
+    name = args[0].strip('"\'')
+    if not state.store.exists(name):
+        T.error(f"Project '{name}' not found.")
+        return "continue"
+    
+    project_to_delete = state.store.load(name)
+    state.store.delete(name)
+
+    import os
+    import shutil
+    if project_to_delete and project_to_delete.project_path and os.path.exists(project_to_delete.project_path):
+        if T.confirm(_("delete_dir_confirm", path=project_to_delete.project_path), default=False):
+            try:
+                shutil.rmtree(project_to_delete.project_path)
+                T.success(_("dir_deleted", path=project_to_delete.project_path))
+            except Exception as e:
+                T.error(_("dir_delete_failed", err=str(e)))
+        else:
+            opalacoder_dir = os.path.join(project_to_delete.project_path, ".opalacoder")
+            if os.path.exists(opalacoder_dir):
+                try:
+                    shutil.rmtree(opalacoder_dir)
+                    T.success(_("vcs_deleted"))
+                except Exception as e:
+                    T.error(_("vcs_delete_failed", err=str(e)))
+
+    T.success(f"Project '{name}' deleted.")
+    if state.project.name == name:
+        T.info("Current project was deleted. Please restart OpalaCoder.")
+        return "break"
+
+
+@_registry.register("/lsskills", description="List active skills for this project")
+async def cmd_lsskills(state: REPLState, _args: list[str]) -> None:
+    T.console.print(f"\n[dim]Active skills for this project:[/dim]")
+    for s in state.project_skills:
+        T.console.print(f"  [cyan]{s['name']}[/cyan]  [dim]{s['description']}[/dim]")
+    T.console.print()
+
+
+@_registry.register("/skills", description="List all available skills (active marked with *)")
+async def cmd_skills(state: REPLState, _args: list[str]) -> None:
+    from .skills import _skill_search_dirs, _parse_skill_file
+    import os as _os
+    search_dirs = _skill_search_dirs(state.project.project_path)
+    found_any = False
+    for s_dir in search_dirs:
+        if not _os.path.isdir(s_dir):
+            continue
+        files = sorted(f for f in _os.listdir(s_dir) if f.endswith(".md"))
+        if not files:
+            continue
+        T.console.print(f"\n[dim]Skills in [bold]{_escape(s_dir)}[/bold]:[/dim]")
+        for filename in files:
+            skill = _parse_skill_file(_os.path.join(s_dir, filename))
+            if skill:
+                active = "[green]*[/green] " if skill["name"] in state.project.skills else "  "
+                T.console.print(f"  {active}[cyan]{skill['name']}[/cyan]  [dim]{skill['description']}[/dim]")
+        found_any = True
+    if not found_any:
+        T.info("No skill files found.")
+    T.console.print(f"\n[dim]([green]*[/green] = active in this project)[/dim]\n")
+
+
+@_registry.register("/addskill", usage="<name>", description="Add a skill to this project")
+async def cmd_addskill(state: REPLState, args: list[str]) -> str | None:
+    from .skills import find_skill_file, load_project_skills
+    if not args:
+        T.error("Usage: /addskill <skill_name>")
+        return "continue"
+    skill_name = args[0].strip().lower()
+    if skill_name in state.project.skills:
+        T.info(f"Skill '{skill_name}' is already active.")
+        return "continue"
+    found = find_skill_file(skill_name, state.project.project_path)
+    if not found:
+        T.error(f"Skill '{skill_name}.md' not found in any skills directory.")
+    else:
+        state.project.skills.append(skill_name)
+        state.store.save(state.project)
+        state.project_skills = load_project_skills(state.project.project_path, state.project.skills)
+        T.success(f"Skill '{skill_name}' added to project.")
+
+
+@_registry.register("/rmskill", usage="<name>", description="Remove a skill from this project")
+async def cmd_rmskill(state: REPLState, args: list[str]) -> str | None:
+    from .skills import load_project_skills
+    if not args:
+        T.error("Usage: /rmskill <skill_name>")
+        return "continue"
+    skill_name = args[0].strip().lower()
+    if skill_name == "opalacoder":
+        T.error("Skill 'opalacoder' is required and cannot be removed.")
+        return "continue"
+    if skill_name not in state.project.skills:
+        T.info(f"Skill '{skill_name}' is not active in this project.")
+        return "continue"
+    state.project.skills.remove(skill_name)
+    state.store.save(state.project)
+    state.project_skills = load_project_skills(state.project.project_path, state.project.skills)
+    T.success(f"Skill '{skill_name}' removed from project.")
+
+
+@_registry.register("/undo", description=_("undo_desc"))
+async def cmd_undo(state: REPLState, _args: list[str]) -> str | None:
+    from .vcs import get_vcs_strategy
+    from .config import get_git_strategy
+    vcs = get_vcs_strategy(get_git_strategy(), state.project.project_path)
+    success, msg = vcs.undo_last()
+    if success:
+        T.success(_("undo_success"))
+    else:
+        T.error(_("undo_fail") + f" ({msg})")
+    return "continue"
+
+
+@_registry.register("/commit", usage="<message>", description=_("commit_desc"))
+async def cmd_commit(state: REPLState, args: list[str]) -> str | None:
+    if not args:
+        T.error("Usage: /commit <message>")
+        return "continue"
+    message = " ".join(args).strip('"\'')
+    from .vcs import get_vcs_strategy
+    from .config import get_git_strategy
+    vcs = get_vcs_strategy(get_git_strategy(), state.project.project_path)
+    success, msg = vcs.manual_commit(message)
+    if success:
+        T.success(_("commit_success"))
+    else:
+        T.error(_("commit_fail", err=msg))
+    return "continue"
+
+
+@_registry.register("/exit", "/quit", description=_("exit_desc"))
+async def cmd_exit(_state: REPLState, _args: list[str]) -> str:
+    T.info(_("exiting"))
+    return "break"