Revolucione las Actualizaciones de su Base de Código con o3-mini de ChatGPT: El Futuro del Desarrollo Automatizado

En esta publicación, exploro cómo el modelo o3-mini LLM de ChatGPT está transformando la forma en que actualizo mi base de código. Este enfoque innovador simplifica las correcciones de errores y la implementación de nuevas funciones en archivos Python, JavaScript y JSON de configuración de manera unificada y semiautomatizada.

Introduciendo o3-mini

Una de las principales fortalezas de o3-mini es su gran tamaño de contexto, que le permite procesar bases de código completas de manera efectiva. o3-mini tiene una ventana de contexto de 200,000 tokens y una salida máxima de 100,000 tokens (vea el lanzamiento oficial de la API o3-mini aquí). Esto significa que o3-mini puede acomodar múltiples archivos fuente en un solo prompt, permitiendo un análisis y modificaciones de código exhaustivos en archivos interdependientes. Esto lo hace ideal para actualizaciones de bases de código a gran escala sin requerir entradas fragmentadas.

El modelo o3-mini es un modelo de lenguaje ligero pero potente disponible a través del navegador ChatGPT. Excel en interpretar instrucciones en lenguaje natural, lo que lo hace perfecto para automatizar modificaciones complejas en la base de código. Para obtener más información sobre las capacidades de ChatGPT y sus modelos, visite ChatGPT.

Mi Caso de Uso: Usar o3-mini para Automatizar Cambios en la Base de Código

Mis proyectos, construidos principalmente en Python y JavaScript con algunos archivos de configuración JSON, necesitaban un método confiable para manejar las modificaciones de código de manera eficiente. Aquí se explica cómo lo logré:

• Correcciones de Errores y Adiciones de Funciones: o3-mini analiza toda mi base de código, asegurando la coherencia entre archivos al abordar errores o agregar nuevas funcionalidades.
• Actualizaciones Completas: En lugar de actualizar los archivos uno por uno, utilizo un análisis de toda la base de código, lo que permite que el modelo proponga cambios interdependientes de manera coherente y unificada.

El Enfoque

Mi enfoque implica crear un prompt que incluya la instrucción y el código completo de la base de proyecto en un formato estructurado. Luego, instruyo al modelo para que genere los archivos modificados en formato JSON. El modelo o3-mini procesa este prompt y su respuesta se captura para aplicar los cambios a la base de código.

Este enfoque está respaldado por dos scripts:

• generate_codebase_prompt.py: Automatiza la creación de un prompt estructurado que incluye toda la base de código.
• apply_changes.py: Analiza la salida del modelo y actualiza los archivos correspondientes en la base de código.

Estos scripts en Python se pueden encontrar al final de esta publicación.

Este método proporciona una manera clara, organizada y escalable de aplicar cambios de código de manera coherente en todo el proyecto.

El Flujo de Trabajo

El siguiente diagrama ilustra mi flujo de trabajo para instruir e implementar cambios en mi base de código utilizando o3-mini:

Las secciones a continuación describen cada paso del flujo de trabajo en detalle.

1. Creando una Instantánea de la Base de Código

Creé un archivo codebase.txt en la raíz del proyecto que lista todos los nombres de archivos (con rutas relativas) en líneas separadas. Esta instantánea es esencial para identificar los archivos a procesar.

2. Generando un Prompt Unificado

Utilizo un script en Python llamado generate_codebase_prompt.py para automatizar este paso.

generate_codebase_prompt.py funciona de la siguiente manera:

• Lee codebase.txt, ignorando las líneas que comienzan con #, para recopilar las rutas de los archivos.
• Lee el contenido completo de cada archivo y maneja los errores de manera elegante si un archivo no se puede leer.
• Construye una matriz JSON donde cada entrada contiene el nombre del archivo (con la ruta) y el contenido del archivo, y luego lo agrega a un texto de prompt fijo.

Este prompt instruye a o3-mini a generar solo los archivos modificados, manteniendo el mismo nombre de archivo (con la ruta) y el contenido actualizado. Instruye al modelo para que genere los resultados en formato JSON con una estructura dada. Aquí está la estructura genérica del prompt:

You are an AI assistant tasked with modifying a codebase based on the instruction provided above. The full codebase is provided below as a
JSON array, where each object represents a file with its relative path and complete contents. Your job is to apply the instruction and retu
rn a pure JSON object that includes only the modified files along with a brief explanation of the changes.

The JSON object must have exactly two keys:
  - "files": an array of objects, each with:
       - "path": the relative file path
       - "content": the full content of the modified file
  - "explanation": a concise explanation of the modifications made

Do not include any additional text, markdown formatting, or commentary outside this JSON object.

Codebase:
...

Para copiar rápidamente el prompt generado en ChatGPT, utilizo el siguiente comando:

python3 generate_codebase_prompt.py ./codebase.txt | xclip -selection clipboard

Usar xclip asegura que la salida se coloque directamente en el portapapeles, permitiéndome pegarla en ChatGPT sin pasos adicionales. Para instalar xclip en Ubuntu, ejecute el siguiente comando:

sudo apt update && sudo apt install xclip

3. Interactuando con ChatGPT

Utilizando el prompt generado, interactúo con ChatGPT proporcionando una instrucción clara.

"Implemente la nueva función ..."

o

"Corrija este error ..."

Después de escribir mi instrucción, pego el prompt generado en el paso anterior con la base de código, que ya está en mi portapapeles. La captura de pantalla a continuación muestra la interacción con ChatGPT.

4. Ejecutando o3-mini y Capturando la Salida

Ejecuto o3-mini con el prompt y capturo su salida en un archivo de texto. Esta salida contiene los cambios formateados en JSON, detallando solo los archivos modificados. Copio fácilmente los resultados del botón Copy de ChatGPT y los pego en un archivo de texto que utilizaré en el siguiente paso. La captura de pantalla a continuación muestra la salida de o3-mini y el botón Copiar.

5. Actualizando la Base de Código

Utilizo el script en Python apply_changes.py para aplicar los cambios generados por ChatGPT. Este script procesa un archivo JSON que contiene los archivos modificados y su nuevo contenido, y luego actualiza o crea los archivos en consecuencia. Asegura que los directorios necesarios existan, escribe el nuevo contenido y registra los cambios.

Para ejecutar el script, utilizo el siguiente comando, donde inputs.txt es el archivo donde capturé la salida de ChatGPT en el paso anterior.

python3 apply_changes.py ./inputs.txt

Ejemplo de la salida del script de actualización:

Updated: ./app/[locale]/top/page.tsx
Updated: ./components/navigation/Header.tsx
Total files updated: 2

6. Verificando Cambios y Pruebas

Después de aplicar los cambios, ejecuto git diff para revisar todas las modificaciones, asegurándome de que se alineen con las actualizaciones previstas. Finalmente, ejecuto algunas pruebas para confirmar que todo funcione.

Casos Prácticos: Proyecto de Blog Next.js

El proyecto que evalúo para actualizaciones de la base de código en esta publicación es un proyecto de blog Next.js. Aquí hay algunas métricas clave sobre el proyecto:

A continuación se presentan varios casos prácticos en los que aplico estas actualizaciones automatizadas a este proyecto de blog Next.js.

Instrucción 1

Para mejorar la experiencia del usuario, decidí agregar una nueva entrada de menú llamada Top a la izquierda de "Blog" en el encabezado de la página principal.

En el encabezado de la página principal, agregue una nueva entrada de menú a la izquierda de "Blog", llamada Top (con T mayúscula). Considere que este es un blog multilingüe y todas las etiquetas en el menú superior tienen traducciones por idioma. Implemente algo equivalente para Top de modo que en todos los idiomas la etiqueta permanezca como Top. Al presionar Top, se mostrarán las entradas de publicaciones destacadas.

Este cambio introdujo un error, que abordo en el siguiente paso.

Instrucción 2

Después de implementar la nueva entrada de menú, encontré un error relacionado con el manejo de rutas dinámicas en Next.js. Instruí al modelo para que corrigiera el error.

Al presionar Top obtengo este error. Corrígelo.

Error: Route "/[locale]/top" used params.locale. params should be awaited before using its properties. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis
   at locale (app/[locale]/top/page.tsx:13:10)
 11 |
 12 | export default async function TopPage({ params }: PageProps) {
 13 |   const { locale } = params
    |          ^
 14 |   const sortedPosts = sortPosts(allBlogs)
 15 |   const posts = allCoreContent(sortedPosts)
 16 |   const featuredPosts = posts.filter((p) => p.language === locale && p.featured === true)

En este punto, la nueva función funcionó como se esperaba.

Instrucción 3

Para mejorar la experiencia del usuario, decidí eliminar la limitación de mostrar solo dos publicaciones destacadas al seleccionar Top.

Al seleccionar Top se mostrarán todas las publicaciones destacadas. Actualmente hay una limitación de dos. Sin embargo, en la página principal mantendrá un máximo de dos publicaciones destacadas como se implementa ahora.

El cambio funcionó como se esperaba.

Instrucción 4

Durante el proceso de compilación, encontré un error de formato relacionado con Prettier. Instruí al modelo para que corrigiera el error.

Corrija este error

  Linting and checking validity of types  .. ⚠ TypeScript project references are not fully supported. Attempting to build in incremental mode.

Failed to compile.

./app/[locale]/top/page.tsx
18:38  Error: Replace p with (p)  prettier/prettier

./components/navigation/Header.tsx
59:53  Error: Replace {link.title·===·'Top'·?·'Top'·:·t(link.title.toLowerCase())} with ⏎······················{link.title·===·'Top'·?·'Top'·:·t(link.title.toLowerCase())}⏎····················  prettier/prettier

info  - Need to disable some ESLint rules? Learn more here: https://nextjs.org/docs/app/api-reference/config/eslint#disabling-rules

El error de formato fue corregido.

Conclusión

Utilizar o3-mini para analizar y actualizar una base de código completa ofrece varias ventajas:

• Visión Integral: El LLM considera la imagen completa, proponiendo cambios que tienen en cuenta las dependencias entre múltiples archivos.
• Coherencia: Las actualizaciones automatizadas aseguran que las modificaciones interdependientes se apliquen de manera uniforme.
• Eficiencia: Aunque el tiempo de procesamiento depende del tamaño de la base de código, el flujo de trabajo general es rápido y efectivo.
• Flujo de Trabajo de Desarrollo Mejorado: Este método minimiza la intervención manual, reduce los errores y acelera tanto las correcciones de errores como la implementación de funciones.

Al darle acceso al modelo a una base de código completa, he optimizado mi proceso de desarrollo y demostrado que las actualizaciones automatizadas y unificadas pueden ser más inteligentes y coherentes que manejar los archivos individualmente.

Los modelos con ventanas de contexto ampliadas y límites de salida aumentados, como o3-mini, permiten este enfoque.

Próximos Pasos

No he utilizado o3-mini-high para estos ejemplos, pero el enfoque sigue siendo válido. En el futuro, planeo evaluar también este modelo para comparar su eficacia y rendimiento en la automatización de actualizaciones de la base de código.

El siguiente paso natural será construir una herramienta que automatice este flujo de trabajo utilizando la API de o3-mini. Esta herramienta seguiría el enfoque estructurado descrito en esta publicación, permitiendo modificaciones de la base de código sin problemas mientras se integra directamente con un repositorio Git para realizar commits de actualizaciones de manera eficiente. Al usar o3-mini a través de la API, el proceso puede ser completamente automatizado, reduciendo la intervención manual y asegurando mejoras estructuradas y controladas de versiones en los proyectos.

Scripts en Python

A continuación se presentan los scripts en Python utilizados en este flujo de trabajo. Estos scripts automatizan el proceso de generar prompts y aplicar cambios a la base de código, haciendo que el flujo de trabajo sea eficiente y escalable.

generate_codebase_prompt.py

Este script lee una lista de rutas de archivos, extrae su contenido y los formatea en un prompt estructurado que se puede utilizar con un LLM para analizar y modificar la base de código.

"""
generate_codebase_prompt.py
================

Description:
    This script reads a file containing file paths (one per line), ignoring any lines
    that start with the '#' character. For each valid file path, it reads the full file
    contents and constructs a JSON array where each element is an object containing the file's
    "path" and "content". This JSON array is appended to a fixed prompt text which is intended
    for use with a Language Model (LLM) to modify the codebase based on a manually added instruction.

Usage:
    python generate_codebase_prompt.py <file_with_paths>

    Where:
        <file_with_paths> is a text file containing a list of file paths (one per line).

Example:
    Given an input file 'paths.txt' with the following content:
        /path/to/file1.txt
        # /path/to/file2.txt

    Running:
        python generate_codebase_prompt.py paths.txt

    Produces output (on standard output) similar to:
        === PROMPT ===
        You are an AI assistant tasked with modifying a codebase based on the instruction provided above.
        The full codebase is provided below as a JSON array, where each object represents a file with its
        relative path and complete contents. Your job is to apply the instruction and return a pure JSON
        object that includes only the modified files along with a brief explanation of the changes.

        The JSON object must have exactly two keys:
          - "files": an array of objects, each with:
               - "path": the relative file path
               - "content": the full content of the modified file
          - "explanation": a concise explanation of the modifications made

        Do not include any additional text, markdown formatting, or commentary outside this JSON object.

        Codebase:
        [
          {
            "path": "/path/to/file1.txt",
            "content": "full contents of file1..."
          },
          ...
        ]
"""

import sys
import json


def generate_codebase_json(file_with_paths):
    """
    Reads an input file containing file paths and generates a list of dictionaries,
    each representing a file with its "path" and full "content".

    The function ignores empty lines and lines starting with '#' (treated as comments).
    If an error occurs while reading any file, the error message is stored in the "content" field
    of the corresponding dictionary.

    Args:
        file_with_paths (str): Path to the text file containing file paths.

    Returns:
        list: A list of dictionaries with keys "path" and "content".

    Exits:
        Exits the script with a status code 1 if the input file cannot be read.
    """
    codebase = []
    try:
        with open(file_with_paths, 'r') as f:
            for line in f:
                filepath = line.strip()
                # Skip empty lines and commented lines
                if not filepath or filepath.startswith("#"):
                    continue
                try:
                    with open(filepath, 'r', encoding="utf-8") as file_content:
                        content = file_content.read()
                    codebase.append({"path": filepath, "content": content})
                except Exception as e:
                    # If there is an error reading the file, record the error message as content
                    codebase.append({"path": filepath, "content": f"Error reading file: {e}"})
        return codebase
    except Exception as e:
        print(f"Error reading input file {file_with_paths}: {e}")
        sys.exit(1)


def print_prompt_with_codebase(codebase):
    """
    Constructs and prints a complete prompt intended for an LLM. The prompt consists of
    a fixed text instruction followed by a JSON array of the codebase.

    The fixed prompt instructs the LLM to modify the codebase based on a manually added
    instruction and to output a JSON object with two keys: "files" and "explanation".

    Args:
        codebase (list): A list of dictionaries where each dictionary contains the "path" and
                         "content" of a file.
    """
    # Fixed prompt text (the manual instruction is expected to be added before this text)
    prompt_text = (
        "You are an AI assistant tasked with modifying a codebase based on the instruction provided above. "
        "The full codebase is provided below as a JSON array, where each object represents a file with its relative path "
        "and complete contents. Your job is to apply the instruction and return a pure JSON object that includes only the "
        "modified files along with a brief explanation of the changes.\n\n"
        "The JSON object must have exactly two keys:\n"
        "  - \"files\": an array of objects, each with:\n"
        "       - \"path\": the relative file path\n"
        "       - \"content\": the full content of the modified file\n"
        "  - \"explanation\": a concise explanation of the modifications made\n\n"
        "Do not include any additional text, markdown formatting, or commentary outside this JSON object.\n\n"
        "Codebase:"
    )

    # Convert the codebase list to a JSON string with indentation for better readability
    codebase_json = json.dumps(codebase, indent=2)

    # Output the complete prompt
    print(prompt_text)
    print("\n" + codebase_json)


def main():
    """
    Main function that handles command-line arguments and executes the script functionality.
    """
    if len(sys.argv) != 2:
        print("Usage: python process_files.py <file_with_paths>")
        sys.exit(1)

    file_with_paths = sys.argv[1]
    codebase = generate_codebase_json(file_with_paths)
    print_prompt_with_codebase(codebase)


if __name__ == "__main__":
    main()

apply_changes.py

Este script procesa la salida JSON del LLM, actualiza los archivos correspondientes en la base de código y asegura que los cambios se apliquen de manera coherente mientras se preservan las estructuras de directorios.

"""
apply_changes.py
===============

Description:
    This script reads a JSON file provided as a command-line argument. The JSON file must contain
    an object with a key "files", which is an array of objects. Each object in the array should
    have the following keys:
      - "path": the relative or absolute path of the file to update
      - "content": the full content to write into that file

    The script updates or creates each file as specified in the JSON file. Necessary directories
    are created if they do not exist.

Usage:
    python apply_changes.py /path/to/input.json

Example JSON file structure:
    {
      "files": [
        {
          "path": "example/file1.txt",
          "content": "This is the updated content for file1."
        },
        {
          "path": "example/file2.txt",
          "content": "This is the updated content for file2."
        }
      ]
    }
"""

import os
import sys
import json


def update_files_from_json(json_file_path):
    """
    Reads a JSON file and updates or creates files as specified in the JSON object.

    The JSON file must contain an object with a key "files", which is an array of objects.
    Each object must have:
      - "path": the relative or absolute path of the file to update
      - "content": the full content to write into that file

    The function creates any necessary directories for the file paths if they do not exist.
    It prints a message for each file that is updated and a final summary of the total files updated.

    Args:
        json_file_path (str): The path to the JSON file containing file update information.

    Exits:
        The script exits with status code 1 if the JSON file cannot be read or if it does not
        contain the required "files" key.
    """
    try:
        with open(json_file_path, 'r', encoding='utf-8') as f:
            data = json.load(f)
    except Exception as e:
        print("Error reading JSON file '{}': {}".format(json_file_path, e))
        sys.exit(1)

    if 'files' not in data:
        print("Invalid JSON format: missing 'files' key.")
        sys.exit(1)

    files_updated = 0
    for file_obj in data['files']:
        try:
            file_path = file_obj['path']
            content = file_obj['content']
            # Create necessary directories if they do not exist.
            directory = os.path.dirname(file_path)
            if directory and not os.path.exists(directory):
                os.makedirs(directory, exist_ok=True)
            # Write the content to the file.
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(content)
            print("Updated: {}".format(file_path))
            files_updated += 1
        except Exception as e:
            print("Failed to update '{}': {}".format(file_obj.get('path', 'unknown'), e))
    print("Total files updated: {}".format(files_updated))


def main():
    """
    Main function that handles command-line arguments and triggers the file update process.
    """
    if len(sys.argv) != 2:
        print("Usage: python update_files.py /path/to/input.json")
        sys.exit(1)

    json_file_path = sys.argv[1]
    update_files_from_json(json_file_path)


if __name__ == '__main__':
    main()

¿Disfrutaste esta publicación? ¿Encontraste útil? Siéntete libre de dejar un comentario a continuación para compartir tus pensamientos o hacer preguntas. Se requiere una cuenta de GitHub para unirse a la discusión.