codeshift-ai 0.1.0__py3-none-any.whl

_codeshift/agents/clean.py

@@ -0,0 +1,23 @@
+import re
+
+# ```json ... ``` ou ``` ... ```
+_FENCE = re.compile(r"```[a-zA-Z0-9_-]*\s*(.*?)```", re.DOTALL)
+
+
+def clean_json(text: str) -> str:
+    """Remove cercas de markdown e texto solto em volta, deixando só o objeto JSON."""
+
+    text = text.strip()
+
+    fenced = _FENCE.search(text)
+    if fenced:
+        text = fenced.group(1).strip()
+
+    # cerca aberta e nunca fechada (resposta cortada)
+    text = text.removeprefix("```json").removeprefix("```").strip()
+
+    start, end = text.find("{"), text.rfind("}")
+    if start != -1 and end > start:
+        text = text[start:end + 1]
+
+    return text.strip()

_codeshift/agents/refactor.py

@@ -0,0 +1,205 @@
+from _codeshift.logs import logger 
+from .response.interface import ModelResponse
+from _codeshift.utils.file import FileControl
+from _codeshift.utils.tree import Tree
+from _codeshift.prompt.prompts import REFACTOR
+from ..schema import OutPutMapping
+from .clean import clean_json
+import json
+import os
+class RefactorAgent(ModelResponse, Tree, FileControl): 
+
+    def __init__(self)->None:
+        super().__init__()
+        Tree.__init__(self)  # Settings.__init__ não chama super(), então o Tree precisa ser iniciado aqui
+        self.prompt:str = REFACTOR
+
+    def _info(self, label: str, value: str) -> None:
+        print(f"  {self.color.gray('•')} {self.color.bold(self.color.blue(label + ':'))} {value}")
+
+    def _progress(self) -> tuple[int, int]:
+        """Conta (visited, total) de arquivos na árvore salva."""
+        files = [n for n in self._walk(self.get_tree()) if n["type"] == "file"]
+        visited = sum(1 for n in files if n.get("status") == "visited")
+        return visited, len(files)
+
+    def cli(self) -> None:
+        c = self.color
+
+        self._header("🛠  Refatoração do projeto")
+
+        print()
+        self._info("Modelo", c.green(self.name))
+        self._info("Temperatura", c.yellow(self.temperature))
+        self._info("Projeto", c.cyan(os.path.abspath(self.root)))
+
+        print(c.cyan("\n⏳ Carregando o modelo, isso pode demorar um pouco...\n"))
+        self.load()
+        print(c.green(f"✔ Modelo {c.bold(self.name)} pronto!"))
+
+        self._header("🔄  Executando")
+        try:
+            self.refactor()
+        except KeyboardInterrupt:
+            print(c.yellow("\n\n⚠ Interrompido pelo usuário. O progresso fica salvo na árvore."))
+        except Exception as error:
+            print(c.red(f"\n✖ Erro durante a refatoração: {error}"))
+            raise
+        else:
+            print(c.green("\n✔ Refatoração concluída!"))
+        finally:
+            visited, total = self._progress()
+            line = c.purple("─" * 50)
+            print(f"\n{line}")
+            print(f"  {c.bold('Resumo')}")
+            print(f"  {c.green(f'{visited} visitados')} {c.gray('·')} {c.yellow(f'{total - visited} pendentes')} "
+                  f"{c.gray('·')} {c.blue(f'{total} arquivos')}")
+            print(f"  {c.gray('Árvore em')} {c.bold(os.path.abspath(self.file_path))}")
+            print(f"{line}\n")
+
+    BLOCKED = {".git", ".venv", "venv", "node_modules", "__pycache__", ".codeshift"}
+
+    def _check_path(self, path: str) -> None:
+        """Garante que o caminho fica dentro do projeto e fora das pastas proibidas."""
+        norm = os.path.normpath(path)
+        parts = norm.split(os.sep)
+        if os.path.isabs(norm) or ".." in parts:
+            raise PermissionError(f"Path outside the project: {path}")
+        if any(part in self.BLOCKED for part in parts) or os.path.basename(norm).startswith(".env"):
+            raise PermissionError(f"Path not allowed: {path}")
+
+    def _files(self, status: str) -> list[str]:
+        """Caminhos dos arquivos da árvore com o status dado."""
+        return [n["path"] for n in self._walk(self.get_tree()) if n["type"] == "file" and n.get("status") == status]
+
+    def _pending_hint(self) -> str:
+        pending = self._files("pending")
+        return "Valid pending paths: " + (", ".join(pending) if pending else "none")
+
+    def _run_action(self, action) -> str:
+        """Executa uma ação e devolve o texto do resultado."""
+        arg = action.arg
+
+        match action.name:
+
+            case "save":
+                self._check_path(arg[0])
+                if os.path.exists(arg[0]):
+                    return f"ERROR: {arg[0]} already exists. save only creates NEW files; use update to replace an existing file."
+                self.save(path=arg[0], data=arg[1], type="txt")
+                return f"Saved path {arg[0]}"
+
+            case "read":
+                self._check_path(arg)
+                text = self.read(path=arg, type="txt")
+                self._read.add(os.path.normpath(arg))
+                return f"{arg}:\n{text}"
+
+            case "update_status":
+                self._check_path(arg[0])
+                return f"Status updated: {self.update_status(name=arg[0], status=arg[1])} -> {arg[1]}"
+
+            case "update":
+                self._check_path(arg[0])
+                self._check_path(arg[1])
+                if os.path.normpath(arg[0]) not in self._read:
+                    return f"ERROR: you have not read {arg[0]}. Use read first, then write its C++ from the real code."
+                old, new = os.path.normpath(arg[0]), os.path.normpath(arg[1])
+                if os.path.dirname(old) != os.path.dirname(new):
+                    return f"ERROR: new_path must stay in the same folder as {arg[0]}. Use {os.path.splitext(arg[0])[0]}.cpp or .hpp."
+                if os.path.splitext(new)[1] not in (".cpp", ".hpp", ".h"):
+                    return f"ERROR: new_path must end in .cpp, .hpp or .h, got {arg[1]}."
+                self.update(path=arg[0], new_path=arg[1], content=arg[2])
+                return f"{arg[0]} updated for {arg[1]}"
+
+        return f"Unknown action {action.name}"
+
+    def refactor(self) -> None:
+        """
+        Resposta esperada do modelo (JSON):
+        {
+          "actions": [{"name": "...", "arg": ...}],
+          "content": "resumo do que foi feito e do que vem a seguir"
+        }
+
+        name -> arg:
+          read          -> "caminho"
+          save          -> [caminho, conteudo]
+          update        -> [caminho_atual, novo_caminho, novo_conteudo]
+          update_status -> [caminho, "visited" | "pending"]
+          quit          -> sem arg
+        As actions rodam em ordem; cada uma é uma chamada separada.
+        """
+
+        report = ""   # resultado das ações do turno anterior
+        notes = ""    # "content" que o modelo escreveu no turno anterior
+        read_paths: set[str] = set()
+        self._read: set[str] = set()
+
+        while True:
+
+            parts = []
+            if report:
+                parts.append(f"RESULT OF YOUR LAST ACTIONS:\n{report}")
+            if notes:
+                parts.append(f"WHAT YOU DID IN THE LAST TURN:\n{notes}")
+            pending = self._files("pending")
+            parts.append("PENDING FILES (use these exact paths, never paths from the examples):\n"
+                         + ("\n".join(f"- {path}" for path in pending) if pending else "(none)"))
+            parts.append(f"PROJECT TREE:\n{self.get_tree()}")
+
+            raw = self.response(prompt=self.prompt, input=[{"role": "user", "content": "\n\n".join(parts)}])
+
+            try:
+                response = OutPutMapping.model_validate_json(clean_json(raw))
+            except ValueError as error:
+                report = f"Your last reply was not valid JSON in the required format. Answer again with ONLY the JSON object. {error}"
+                continue
+
+            results = []
+            done = False
+            marked: list[str] = []
+
+            for action in response.actions:
+
+                if action.name == "quit":
+                    left = [path for path in self._files("pending") if path.endswith(".py")]
+                    if left:
+                        results.append("ERROR: you cannot quit yet, these Python files are still pending: " + ", ".join(left))
+                    else:
+                        done = True
+                    break
+
+                try:
+                    result = self._run_action(action)
+                    if action.name == "update_status" and action.arg[1] == "visited":
+                        marked.append(action.arg[0])
+                    if action.name == "read":
+                        if action.arg in read_paths:
+                            result += (f"\nHINT: you already read {action.arg}. Do NOT read it again. "
+                                       "Now write its C++ version: update_status, then update.")
+                        read_paths.add(action.arg)
+                    results.append(result)
+                except Exception as error:
+                    results.append(f"ERROR in {action.name}: {error}. {self._pending_hint()}")
+                    break  # as próximas ações dependem desta
+
+            if done:
+                return
+
+            # um .py marcado como visited mas ainda existente não foi substituído por C++
+            for path in marked:
+                if path.endswith(".py") and os.path.exists(path):
+                    self.update_status(name=path, status="pending")
+                    results.append(
+                        f"ERROR: {path} was NOT replaced, it still exists as Python, so it is pending again. "
+                        f"Replace it now with update: [\"{path}\", \"<same path with .cpp or .hpp>\", \"<complete C++ code>\"]. "
+                        "Do not use save for it."
+                    )
+
+            report = "\n".join(results)
+            notes = response.content
+
+
+if __name__ == "__main__":
+    RefactorAgent().cli()

_codeshift/agents/response/interface.py

@@ -0,0 +1,68 @@
+from _codeshift.settings.config import Settings
+from .openai import ModelOpenAi
+from .transformer import ModelTransform
+
+class ModelResponse(Settings):
+
+    def __init__(self)->None:
+        super().__init__()
+
+        config = self.get_config()
+        self.name = config["model"]["name"]
+        self.temperature = config["model"]["temperature"]
+
+        self.secrets = self.get_envs()
+        self._get_instance()
+
+
+    def _get_instance(self) -> None:
+
+        if self.secrets["url"] is not None:
+
+            self.instance = ModelOpenAi(url=self.secrets["url"], key=self.secrets["api_key"],
+                                        name=self.name, temperature=self.temperature)
+
+        else:
+
+            self.instance = ModelTransform(name=self.name, temperature=self.temperature)
+
+    def start(self) -> bool:
+        """Pergunta se quer carregar o modelo agora. Devolve True se o modelo ficou pronto."""
+
+        c = self.color
+        self._header("🤖  Carregar modelo")
+        print(f"\n{c.bold(c.blue('Modelo:'))} {c.green(self.name)}")
+        print(f"{c.bold(c.blue('Temperatura:'))} {c.yellow(self.temperature)}\n")
+
+        if not isinstance(self.instance, ModelTransform):
+            print(c.green(f"✔ Usando o servidor {self.secrets['url']}: não precisa carregar aqui."))
+            print(c.gray("  Se o modelo não estiver carregado no servidor (LM Studio), carregue lá."))
+            return True
+
+        while True:
+            answer = input(self._prompt("Quer carregar o modelo agora", "Y/n")).strip().lower()
+
+            if answer in ("y", "yes", "s", "sim", ""):
+                print(c.cyan("\n⏳ Carregando, isso pode demorar um pouco...\n"))
+                self.load()
+                print(c.green(f"\n✔ Modelo {c.bold(self.name)} pronto!"))
+                return True
+
+            if answer in ("n", "no", "nao", "não"):
+                print(c.yellow("\n⚠ Modelo não carregado."))
+                return False
+
+            print(c.red("✘ Resposta inválida, digite Y ou n."))
+
+    def load(self) -> None:
+
+        if isinstance(self.instance, ModelTransform):
+            self.instance.load()
+
+    def response(self, prompt:str, input:list) -> str:
+        args = locals()
+        del args["self"]
+        return self.instance.response(**args)
+    
+
+    

_codeshift/agents/response/openai.py

@@ -0,0 +1,38 @@
+from openai import OpenAI
+from _codeshift.logs import logger 
+
+class ModelOpenAi:
+
+    def __init__(self, name:str, temperature:float,url:str, key:str|None=None)-> None:
+
+        self.name = name 
+        self.temperature = temperature
+        self.client = OpenAI(base_url=url, api_key=key if key is not None else "lm-studio") 
+
+
+
+    def response(self, prompt:str, input:list) -> str:
+
+        logger.info(f"Generating response from model {self.name}...")
+        messages = [{"role": "system", "content": prompt}] + input
+
+      
+
+        response = self.client.chat.completions.create(
+            messages=messages,
+            temperature=self.temperature,
+            model=self.name
+        )
+
+        response = response.choices[0].message.content
+
+        logger.success("Response generated with sucess")
+
+        return response
+
+        
+
+
+
+    
+        

_codeshift/agents/response/transformer.py

@@ -0,0 +1,39 @@
+from _codeshift.logs import logger
+class ModelTransform:
+
+    def __init__(self, name:str, temperature:float)-> None:
+        self.name = name 
+        self.temperature = temperature
+        
+
+        
+
+    def load(self) -> None:
+
+        if hasattr(self, "model"):
+            return  # já carregado
+
+        try:
+            from transformers import pipeline
+        except ImportError as error:
+            raise ImportError("Modelo local requer: pip install 'codeshift[local]'") from error
+
+        logger.info(f"Loading model {self.name}...")
+
+        self.model = pipeline("text-generation", model=self.name)
+
+        logger.success(f"{self.name} loaded with success")
+
+
+    def response(self, prompt:str, input:list) -> str:
+
+        logger.info(f"Generating response from model {self.name}...")
+
+        input.insert(0, {"role": "system", "content":prompt})
+
+        resp = self.model(input, temperature=self.temperature, do_sample=True)
+
+        logger.success("Response generated with sucess")
+
+        return resp[0]["generated_text"][-1]["content"]
+

_codeshift/cli.py

@@ -0,0 +1,269 @@
+import json
+import os
+import socket
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from urllib.parse import urlparse
+
+from _codeshift import ui
+
+CONFIG_FILE = ".codeshift/config.json"
+
+# ─── Bonequinho ────────────────────────────────────────────────────────────
+# Pixel art: cada caractere vira um "pixel" de 2 colunas.
+#   B = corpo   E = olho   . = vazio
+# Para trocar o desenho, edite só esta lista (todas as linhas com o mesmo tamanho).
+MASCOT = [
+    "..BBBBBB..",
+    "BBBBBBBBBB",
+    "BBEBBBBEBB",
+    ".BBBBBBBB.",
+    "..BB..BB..",
+]
+MASCOT_COLORS = {"B": ui.ORANGE, "E": ui.DARK}
+
+
+def mascot_lines() -> list[str]:
+    lines = []
+    for row in MASCOT:
+        line = ""
+        for pixel in row:
+            color = MASCOT_COLORS.get(pixel)
+            line += ui.fg("██", color) if color else "  "
+        lines.append(line)
+    return lines
+
+
+# ─── Dados do ambiente ─────────────────────────────────────────────────────
+def _version() -> str:
+    try:
+        return version("codeshift-ai")
+    except PackageNotFoundError:
+        return "dev"
+
+
+def _short_path(path: str) -> str:
+    home = os.path.expanduser("~")
+    return "~" + path[len(home):] if path.startswith(home) else path
+
+
+def read_config() -> dict | None:
+    try:
+        with open(CONFIG_FILE, encoding="utf-8") as file:
+            return json.load(file)
+    except (OSError, ValueError):
+        return None
+
+
+def server_url(config: dict) -> str | None:
+    from dotenv import dotenv_values
+    env_file = config.get("env_file") or ".env"
+    return dotenv_values(env_file).get("url") if os.path.isfile(env_file) else None
+
+
+def server_online(url: str) -> bool:
+    parsed = urlparse(url)
+    host, port = parsed.hostname, parsed.port or (443 if parsed.scheme == "https" else 80)
+    try:
+        with socket.create_connection((host, port), timeout=0.4):
+            return True
+    except OSError:
+        return False
+
+
+def status_lines() -> list[str]:
+    config = read_config()
+    if config is None:
+        return [
+            ui.fg("▲ Sem configuração", ui.YELLOW, bold=True),
+            ui.fg("  use a opção 3 para começar", ui.GRAY),
+        ]
+
+    model = config["model"]
+    name = model["name"].split("/")[-1]
+    lines = [
+        f"{ui.fg('Modelo  ', ui.GRAY)} {ui.fg(name, ui.GREEN, bold=True)} {ui.fg('· temp ' + str(model['temperature']), ui.GRAY)}"
+    ]
+
+    url = server_url(config)
+    if url is None:
+        lines.append(f"{ui.fg('Origem  ', ui.GRAY)} {ui.fg('modelo local (transformers)', ui.CYAN)}")
+    elif server_online(url):
+        lines.append(f"{ui.fg('Servidor', ui.GRAY)} {ui.fg('●', ui.GREEN)} {ui.fg(url, ui.CYAN)}")
+    else:
+        lines.append(f"{ui.fg('Servidor', ui.GRAY)} {ui.fg('●', ui.RED)} {ui.fg(url + ' (offline)', ui.RED)}")
+    return lines
+
+
+# ─── Telas ─────────────────────────────────────────────────────────────────
+def banner() -> None:
+    art = mascot_lines()
+    info = [
+        f"{ui.gradient('CodeShift', ui.ORANGE, ui.PURPLE)} {ui.fg('v' + _version(), ui.GRAY)}",
+        ui.fg("Migração de código para C++ com IA", ui.PURPLE),
+        *status_lines(),
+        f"{ui.fg('Pasta   ', ui.GRAY)} {ui.fg(_short_path(os.getcwd()), ui.BLUE)}",
+    ]
+    info = info[:len(art)] if len(info) > len(art) else info + [""] * (len(art) - len(info))
+
+    wide = ui.width() >= 64
+    rows = [f"{a}   {i}" if wide else i for a, i in zip(art, info)]
+    print()
+    print(ui.box(rows, title="CodeShift" if not wide else "", color=ui.PURPLE))
+
+
+MENU = [
+    ("1", "Migrar projeto para C++", "substitui os .py por C++", ui.GREEN),
+    ("2", "Carregar modelo agora", "prepara o modelo antes de usar", ui.PURPLE),
+    ("3", "Configurar modelo", "escolhe modelo e temperatura", ui.CYAN),
+    ("4", "Atualizar configurações", "muda uma configuração salva", ui.YELLOW),
+    ("5", "Ver árvore do projeto", "lista pastas e arquivos", ui.BLUE),
+    ("0", "Sair", "", ui.RED),
+]
+
+# modelo carregado pelo menu, reaproveitado na migração para não carregar duas vezes
+_loaded = None
+
+
+def show_menu() -> None:
+    label_width = max(len(label) for _, label, _, _ in MENU)
+    rows = []
+    for key, label, hint, color in MENU:
+        rows.append(f"{ui.badge(key, color)}  {ui.pad(ui.fg(label, color, bold=True), label_width)}  {ui.fg(hint, ui.GRAY)}")
+    print()
+    print(ui.box(rows, title="O que você quer fazer?", color=ui.GRAY))
+    print(ui.fg("  digite o número e pressione Enter", ui.GRAY))
+    print()
+
+
+def clear() -> None:
+    if sys.stdout.isatty():
+        print("\033[2J\033[H", end="")
+
+
+def pause() -> None:
+    try:
+        input(f"\n{ui.fg('↵', ui.GRAY)} {ui.fg('Enter para voltar ao menu', ui.GRAY)} ")
+    except (EOFError, KeyboardInterrupt):
+        print()
+
+
+def ask(text: str) -> str:
+    return input(ui.prompt(text)).strip()
+
+
+# ─── Ações ─────────────────────────────────────────────────────────────────
+def require_config() -> bool:
+    if os.path.isfile(CONFIG_FILE):
+        return True
+    ui.warn("Nenhuma configuração encontrada. Use a opção 3 primeiro.")
+    return False
+
+
+def action_migrate() -> None:
+    if not require_config():
+        return
+
+    print()
+    print(ui.box([
+        ui.fg("A migração SUBSTITUI os arquivos .py do projeto atual por C++.", ui.YELLOW, bold=True),
+        ui.fg("Faça um commit ou backup antes de continuar.", ui.YELLOW),
+    ], title="Atenção", color=ui.YELLOW))
+    print()
+
+    if ask("Continuar? (s/N)").lower() not in ("s", "sim", "y", "yes"):
+        print(ui.fg("Cancelado.", ui.GRAY))
+        return
+
+    from _codeshift.agents.refactor import RefactorAgent
+    agent = RefactorAgent()
+    if _loaded is not None:
+        agent.instance = _loaded.instance
+    agent.cli()
+
+
+def action_load() -> None:
+    global _loaded
+    if not require_config():
+        return
+
+    from _codeshift.agents.response.interface import ModelResponse
+    model = ModelResponse()
+    if model.start():
+        _loaded = model
+
+
+def action_configure() -> None:
+    global _loaded
+    from _codeshift.settings.config import Settings
+    Settings().set_settings()
+    _loaded = None
+
+
+def action_update() -> None:
+    global _loaded
+    if not require_config():
+        return
+    from _codeshift.settings.config import Settings
+    Settings().update_settings()
+    _loaded = None
+
+
+def action_tree() -> None:
+    from _codeshift.utils.tree import Tree
+    tree = Tree()
+    tree.build()
+    tree.show()
+
+
+ACTIONS = {
+    "1": action_migrate,
+    "2": action_load,
+    "3": action_configure,
+    "4": action_update,
+    "5": action_tree,
+}
+
+
+def main() -> int:
+    if len(sys.argv) > 1 and sys.argv[1] in ("-v", "--version"):
+        print(f"codeshift {_version()}")
+        return 0
+
+    while True:
+        clear()
+        banner()
+        show_menu()
+
+        try:
+            choice = ask("Escolha uma opção")
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+
+        if choice in ("0", "q", "exit", "sair"):
+            break
+
+        action = ACTIONS.get(choice)
+        if action is None:
+            ui.error("Opção inválida.")
+            pause()
+            continue
+
+        try:
+            action()
+        except KeyboardInterrupt:
+            print()
+            ui.warn("Interrompido.")
+        except Exception as error:
+            print()
+            ui.error(str(error))
+
+        pause()
+
+    print(f"\n{ui.gradient('Até logo!', ui.ORANGE, ui.PURPLE)} 👋\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_codeshift/cmd.py

@@ -0,0 +1,17 @@
+import subprocess
+
+
+def run(command: str) -> str:
+    """Roda um comando no terminal, mostra a saída enquanto ele executa e devolve ela em str."""
+
+    process = subprocess.Popen(
+        command, shell=True, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+    )
+
+    output = ""
+    for line in process.stdout:
+        print(line, end="")
+        output += line
+
+    process.wait()
+    return output