# Instalar PowerShell 7 vía winget si no lo tienes
winget install --id Microsoft.PowerShell -e

# Verificar versión
$PSVersionTable.PSVersion   # debe ser 7.x.x

# Abrir siempre desde Windows Terminal (instalar desde Microsoft Store si no lo tienes)
# Buscá "Windows Terminal" en la tienda de Microsoft

# Install PowerShell 7 via winget if you don't have it
winget install --id Microsoft.PowerShell -e

# Verify version
$PSVersionTable.PSVersion   # must be 7.x.x

# Always open from Windows Terminal (install from Microsoft Store if you don't have it)
# Search "Windows Terminal" in the Microsoft Store

# 1. Crear cuenta en kimi.com si no tienes una
#    → https://www.kimi.com/membership/pricing

# 2. Suscribirse a un plan que incluya Kimi Code
#    → Los planes de Kimi con acceso a Kimi Code incluyen cuota semanal de requests
#    → La cuota se renueva cada 7 días desde la fecha de suscripción

# 3. Obtener API Key para configuración avanzada (opcional)
#    → https://www.kimi.com/code/console
#    → Crear hasta 5 API Keys (cada una se muestra una sola vez, guardarla bien)

# 1. Create an account at kimi.com if you don't have one
#    → https://www.kimi.com/membership/pricing

# 2. Subscribe to a plan that includes Kimi Code
#    → Kimi plans with Kimi Code access include a weekly request quota
#    → The quota renews every 7 days from the subscription date

# 3. Get an API Key for advanced configuration (optional)
#    → https://www.kimi.com/code/console
#    → Create up to 5 API Keys (each is shown only once, save it securely)

# Installer oficial de Moonshot AI
# Descarga e instala uv (Python package manager) y luego Kimi Code CLI
Invoke-RestMethod https://code.kimi.com/install.ps1 | Invoke-Expression

# Cerrar y reabrir PowerShell (necesario para que el PATH tome efecto)

# Verificar instalación
kimi --version

# Verificar que uv también quedó instalado
uv --version

# Official Moonshot AI installer
# Downloads and installs uv (Python package manager) and then Kimi Code CLI
Invoke-RestMethod https://code.kimi.com/install.ps1 | Invoke-Expression

# Close and reopen PowerShell (needed for PATH to take effect)

# Verify installation
kimi --version

# Verify uv was also installed
uv --version

# Si ya tienes uv instalado, podés instalar Kimi CLI directamente
uv tool install --python 3.13 kimi-cli

# Verificar
kimi --version

# If you already have uv installed, you can install Kimi CLI directly
uv tool install --python 3.13 kimi-cli

# Verify
kimi --version

# El binario (script entry point) queda en:
C:\Users\TuUsuario\.local\bin\kimi.exe  # (o vía uv tool bin path)

# La configuración principal queda en:
C:\Users\TuUsuario\.kimi\config.toml

# Las sesiones, logs y config MCP en:
C:\Users\TuUsuario\.kimi\

# Si kimi no se reconoce como comando, verificar que el PATH incluya:
uv tool bin-path   # muestra dónde instala los binarios uv

# Agregar al PATH manualmente si es necesario:
[Environment]::SetEnvironmentVariable(
    "PATH",
    "$env:PATH;$env:USERPROFILE\.local\bin",
    "User"
)

# The binary (script entry point) goes to:
C:\Users\YourUser\.local\bin\kimi.exe  # (or via uv tool bin path)

# Main configuration goes to:
C:\Users\YourUser\.kimi\config.toml

# Sessions, logs, and MCP config in:
C:\Users\YourUser\.kimi\

# If kimi is not recognized as a command, verify PATH includes:
uv tool bin-path   # shows where uv installs binaries

# Add to PATH manually if needed:
[Environment]::SetEnvironmentVariable(
    "PATH",
    "$env:PATH;$env:USERPROFILE\.local\bin",
    "User"
)

# Navegar a tu proyecto y abrir Kimi Code
cd C:\Users\TuUsuario\Projects\mi-proyecto
kimi

# En la primera sesión, ejecutar el comando de login
/login

# Seleccionar "Kimi Code" como plataforma (recomendado)
# → Abre el browser automáticamente para OAuth
# → Iniciar sesión con tu cuenta Kimi → autorizar → volver al terminal
# → La sesión queda guardada en ~/.kimi/

# Alternativa — API Key manual (para CI/CD o uso headless)
# En /login seleccionar "Custom" y pegar tu API Key del console

# Navigate to your project and open Kimi Code
cd C:\Users\YourUser\Projects\my-project
kimi

# On the first session, run the login command
/login

# Select "Kimi Code" as the platform (recommended)
# → Opens the browser automatically for OAuth
# → Log in with your Kimi account → authorize → return to terminal
# → Session is saved in ~/.kimi/

# Alternative — Manual API Key (for CI/CD or headless use)
# In /login select "Custom" and paste your API Key from the console

# Descarga el binario compilado directamente desde GitHub Releases
# No necesitás Go instalado
irm https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.ps1 | iex

# Verificar
gentle-ai --version

# Download the compiled binary directly from GitHub Releases
# You don't need Go installed
irm https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.ps1 | iex

# Verify
gentle-ai --version

# Agregar el bucket de Gentleman Programming
scoop bucket add gentleman https://github.com/Gentleman-Programming/scoop-bucket

# Instalar gentle-ai
scoop install gentle-ai

# Verificar
gentle-ai --version

# Add the Gentleman Programming bucket
scoop bucket add gentleman https://github.com/Gentleman-Programming/scoop-bucket

# Install gentle-ai
scoop install gentle-ai

# Verify
gentle-ai --version

# Instalar Go 1.24+ primero si no lo tenés
winget install --id GoLang.Go -e

# Compilar e instalar desde fuente (garantiza el latest)
go install github.com/gentleman-programming/gentle-ai/cmd/gentle-ai@latest

# El binario queda en: C:\Users\TuUsuario\go\bin\gentle-ai.exe
# Verificar
gentle-ai --version

# Install Go 1.24+ first if you don't have it
winget install --id GoLang.Go -e

# Compile and install from source (guarantees latest)
go install github.com/gentleman-programming/gentle-ai/cmd/gentle-ai@latest

# Binary goes to: C:\Users\YourUser\go\bin\gentle-ai.exe
# Verify
gentle-ai --version

# Opción A — TUI interactivo (recomendado para primera vez)
# Abre un menú visual donde elegís "kimi" como agente y seleccionás los componentes
gentle-ai install

# Opción B — Instalación directa para Kimi Code
gentle-ai install --agent kimi

# Opción C — Con componentes específicos
gentle-ai install --agent kimi --component engram --component context7 --component gga

# Verificar qué agentes detectó gentle-ai
gentle-ai agents list

# Option A — Interactive TUI (recommended for first time)
# Opens a visual menu where you choose "kimi" as the agent and select components
gentle-ai install

# Option B — Direct installation for Kimi Code
gentle-ai install --agent kimi

# Option C — With specific components
gentle-ai install --agent kimi --component engram --component context7 --component gga

# Verify which agents gentle-ai detected
gentle-ai agents list

# Archivo de agente principal — define el comportamiento del Gentleman
C:\Users\TuUsuario\.kimi\agents\gentleman.yaml

# Prompt principal del agente (Jinja template)
C:\Users\TuUsuario\.kimi\KIMI.md
# Incluye: persona.md, output-style.md, engram-protocol.md, sdd-orchestrator.md

# Base de datos de memoria persistente
C:\Users\TuUsuario\.engram\engram.db

# Config MCP — Context7 y otros servidores
C:\Users\TuUsuario\.kimi\mcp.json

# Git hook para GGA (code review automático)
# Se instala en: .git/hooks/pre-commit (dentro de cada proyecto)

# Main agent file — defines the Gentleman's behavior
C:\Users\YourUser\.kimi\agents\gentleman.yaml

# Main agent prompt (Jinja template)
C:\Users\YourUser\.kimi\KIMI.md
# Includes: persona.md, output-style.md, engram-protocol.md, sdd-orchestrator.md

# Persistent memory database
C:\Users\YourUser\.engram\engram.db

# MCP config — Context7 and other servers
C:\Users\YourUser\.kimi\mcp.json

# Git hook for GGA (automatic code review)
# Installed at: .git/hooks/pre-commit (inside each project)

# Opción A — Cargar el agente gentleman directamente
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Opción B — Configurar el agente como default en config.toml
# Editar C:\Users\TuUsuario\.kimi\config.toml y agregar:
# [agent]
# default_agent_file = "C:/Users/TuUsuario/.kimi/agents/gentleman.yaml"

# Luego simplemente:
kimi

# Opción C — Con modo thinking activado desde el inicio
kimi --thinking --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Option A — Load the gentleman agent directly
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Option B — Set the agent as default in config.toml
# Edit C:\Users\YourUser\.kimi\config.toml and add:
# [agent]
# default_agent_file = "C:/Users/YourUser/.kimi/agents/gentleman.yaml"

# Then simply:
kimi

# Option C — With thinking mode enabled from the start
kimi --thinking --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# El proyecto debe estar en git (requerido por Engram)
git init
git add .
git commit -m "init"

# Engram ya fue configurado automáticamente por gentle-ai install
# Verificar que Engram reconoce el proyecto
engram projects list

# Project must be in git (required by Engram)
git init
git add .
git commit -m "init"

# Engram was already configured automatically by gentle-ai install
# Verify that Engram recognizes the project
engram projects list

# Abrir Kimi con el agente Gentleman en el proyecto
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Analizar el proyecto y generar AGENTS.md (si no existe)
/init

# Iniciar el workflow SDD — detecta stack, testing, activa contexto
/sdd-init

# Escanea skills instaladas y convenciones del proyecto
skill-registry

# Verificar que Engram registró el contexto
engram search "proyecto"   # desde otra terminal

# Open Kimi with the Gentleman agent in the project
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Analyze the project and generate AGENTS.md (if it doesn't exist)
/init

# Start the SDD workflow — detects stack, testing, activates context
/sdd-init

# Scan installed skills and project conventions
skill-registry

# Verify that Engram registered the context
engram search "project"   # from another terminal

# Ver sesiones activas
/sessions

# Reanudar sesión anterior (desde el mismo directorio, Kimi pregunta automáticamente)
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Comprimir el historial cuando el contexto se llena
# (preserva las decisiones clave guardadas en Engram)
/compact

# Buscar contexto previo en Engram desde la terminal
engram search "JWT"          # buscar decisiones sobre JWT
engram search "auth bug"     # buscar bugs de autenticación resueltos
engram tui                    # browser visual de la memoria

# View active sessions
/sessions

# Resume previous session (from the same directory, Kimi asks automatically)
kimi --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Compress history when context fills up
# (preserves key decisions saved in Engram)
/compact

# Search previous context in Engram from the terminal
engram search "JWT"          # search decisions about JWT
engram search "auth bug"     # search resolved authentication bugs
engram tui                    # visual memory browser

# Gestionar MCP servers (interactivo — lista, conecta, desconecta)
kimi mcp

# Dentro de una sesión de Kimi, ver MCP servers conectados
/mcp

# El mcp.json generado por gentle-ai ya incluye Context7
# Para agregar servers adicionales, editar directamente:
# C:\Users\TuUsuario\.kimi\mcp.json

# Iniciar Kimi con un archivo de config MCP específico
kimi --mcp-config-file "$env:USERPROFILE\.kimi\mcp.json" --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Manage MCP servers (interactive — list, connect, disconnect)
kimi mcp

# Inside a Kimi session, view connected MCP servers
/mcp

# The mcp.json generated by gentle-ai already includes Context7
# To add additional servers, edit directly:
# C:\Users\YourUser\.kimi\mcp.json

# Start Kimi with a specific MCP config file
kimi --mcp-config-file "$env:USERPROFILE\.kimi\mcp.json" --agent-file "$env:USERPROFILE\.kimi\agents\gentleman.yaml"

# Abrir la interfaz gráfica en el browser
kimi web

# Soporta: gestión de sesiones, referencias a archivos, highlight de código
# También puede usarse con el agente gentleman configurado como default
# Útil para revisiones visuales y pegar imágenes de diseño (UI → código)

# Kimi K2.6 soporta input multimodal — podés pegar screenshots de diseño
# y pedirle que implemente el componente React correspondiente

# Open the graphical interface in the browser
kimi web

# Supports: session management, file references, code highlighting
# Can also be used with the gentleman agent set as default
# Useful for visual reviews and pasting design images (UI → code)

# Kimi K2.6 supports multimodal input — you can paste design screenshots
# and ask it to implement the corresponding React component