@vitortrack777/djinnai 0.0.0-stage → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vitortrack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
+<h1 align="center">DjinnAI</h1>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center">
+  Uma tela local para conversar com o agente do <strong>Claude Code</strong> dentro do seu projeto.<br>
+  O agente pode ser o <strong>Claude</strong> ou um modelo do <strong>Ollama</strong>, e os comandos do ambiente ficam a um <code>/</code> de distância.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@vitortrack777/djinnai"><img src="https://img.shields.io/npm/v/@vitortrack777/djinnai.svg" alt="versão no npm"></a>
+  <img src="https://img.shields.io/node/v/@vitortrack777/djinnai.svg" alt="node">
+  <a href="LICENSE"><img src="https://img.shields.io/npm/l/@vitortrack777/djinnai.svg" alt="licença MIT"></a>
+</p>
+
+```bash
+npm install -g @vitortrack777/djinnai
+cd meu-projeto
+djinn              # abre o aplicativo (djinn --navegador abre no navegador)
+djinn restart api  # os comandos do ambiente continuam funcionando direto no terminal
+```
+
+---
+
+## Como funciona
+
+`djinn` sobe um servidor em `127.0.0.1`, numa porta livre, e abre a tela num **aplicativo de desktop**
+(Electron, que vem com o pacote), no Linux, no Windows e no macOS, sem depender de navegador.
+**Fechar a janela encerra o DjinnAI.** O endereço também aparece no terminal: dá para abrir no
+navegador ao mesmo tempo, e as duas telas mostram a mesma conversa.
+
+| Comando | Abre |
+|---|---|
+| `djinn` (ou `djinnai`) | A janela do aplicativo. Se ela não abrir (sem ambiente gráfico, por exemplo), cai no navegador padrão |
+| `djinn --navegador` | Só o navegador padrão, como numa aba comum |
+
+A conversa é
+uma sessão do Claude Code aberta na raiz do projeto, no mesmo protocolo que o Agent SDK usa
+(`stream-json` de entrada e saída). Por isso a tela tem o que o Claude Code tem:
+
+- o texto aparece enquanto o agente escreve, com raciocínio, ferramentas, tempo e tokens;
+- o agente **pede permissão** na tela antes de editar ou rodar comando, mostrando o comando ou o diff;
+- o agente **faz perguntas** com opções e **apresenta o plano** para você aprovar no modo Planejar;
+- dá para **mandar mensagem com o agente trabalhando**: ela entra na fila e o agente lê assim que puder;
+- **prints colados** (Ctrl+V) ou arrastados para a tela vão junto com a mensagem;
+- o `/` lista as skills e comandos do Claude Code do projeto, além dos comandos do ambiente;
+- recarregar a página não perde a conversa, que continua até você digitar `/novo` ou fechar o DjinnAI.
+
+Quem decide o que fazer é o agente. O DjinnAI não tem templates nem validadores próprios: ele só repassa
+o pedido, o modelo, o esforço e o modo de permissão, mais o contexto do projeto descrito abaixo.
+
+## Requisitos
+
+| Requisito | Para quê |
+|---|---|
+| [Node.js](https://nodejs.org) 22.12+ (recomendado: 24 LTS) | Executar o DjinnAI e o Electron |
+| [Claude Code](https://docs.anthropic.com/claude-code) instalado e logado (`claude`) | O agente |
+| [Ollama](https://ollama.com) 0.14+ (opcional) | Usar modelos do Ollama como agente |
+| Script `appDev` ou `app` na raiz (opcional) | Os comandos do ambiente (`/start`, `/logs`…) |
+
+## A tela
+
+| Parte | O que faz |
+|---|---|
+| Contexto e **Nova conversa**, no topo | Quantos tokens a conversa já carrega (o agente relê tudo a cada passo). Acima de 100k a tela sugere uma conversa nova; o botão (ou `/novo`) começa uma sessão limpa. Cada `djinn` também começa numa sessão nova |
+| Caixa de pedido | Enter envia, Shift+Enter quebra a linha. Com o agente trabalhando, Enter põe a mensagem na fila e o botão vira **parar** |
+| `/` | Lista `/novo` (conversa nova), os comandos do ambiente (`/start`, `/restart api`, `/logs --tail=100 api`, `/status`…) e as skills do Claude Code. A saída do ambiente aparece na tela, e o botão de parar encerra o comando (útil no `logs -f`) |
+| Seletor de modelo | Os modelos que a sua conta do Claude Code oferece ou qualquer modelo instalado no Ollama. O modelo do Ollama roda **dentro do Claude Code**, com as mesmas ferramentas e os mesmos `CLAUDE.md` |
+| Esforço | Baixo a Máximo, repassado como `--effort` (vale a partir da próxima mensagem com o agente parado) |
+| Modo, no topo | **Planejar** (planeja e pede aprovação do plano; aprovar passa para Editar), **Perguntar** (pede permissão para cada edição e comando), **Editar** (edita sem perguntar; comandos fora das regras do projeto pedem permissão), **Automático** (o Claude Code decide o que é seguro). Muda na hora, mesmo no meio de uma resposta |
+
+No cartão de permissão, **Permitir e não perguntar de novo** grava a regra sugerida pelo Claude Code, como no terminal.
+
+Os comandos destrutivos do ambiente (`execute`, que recria o banco, e `auto-remove`, que apaga
+volumes) não aparecem na tela. Use pelo terminal: `djinn execute <banco> arquivo.sql`.
+
+## Contexto que o agente recebe
+
+O Claude Code já carrega os `CLAUDE.md`, as configurações do projeto (`.claude/`), as skills e o git
+status. O DjinnAI acrescenta ao system prompt (`--append-system-prompt`):
+
+- as pastas versionadas do projeto, até 4 níveis e no máximo 150, para o agente não gastar passos procurando;
+- o conteúdo de `.djinn/contexto.md`, se existir, como instrução.
+
+Use o `.djinn/contexto.md` para o que vale só para você e não pertence ao repositório: vocabulário do
+domínio, armadilhas conhecidas, onde fica cada coisa, o card em andamento. Ele é lido no começo de
+cada conversa: depois de editar, digite `/novo`.
+
+## Configuração
+
+O modelo, o esforço e o modo escolhidos na tela ficam salvos em `.djinn/config.json`:
+
+```json
+{
+  "model": "claude:opus",
+  "effort": "high",
+  "mode": "acceptEdits",
+  "ollamaUrl": "http://127.0.0.1:11434"
+}
+```
+
+O retorno bruto da última mensagem ao agente fica em `.djinn/last-turn.ndjson`, para diagnóstico.
+
+| Variável de ambiente | Descrição |
+|---|---|
+| `DJINN_PORT` | Porta fixa no lugar de uma porta livre |
+| `DJINN_APP_SCRIPT` | Script de ambiente no lugar de `appDev`/`app` |
+
+Projetos que já têm `.detro/` continuam usando essa pasta, e `DETRO_PORT`/`DETRO_APP_SCRIPT` seguem valendo quando a variável `DJINN_` correspondente não está definida.
+
+O DjinnAI remove `ANTHROPIC_API_KEY` do ambiente do agente: o uso conta na sua assinatura do Claude Code,
+não na API paga. Com modelo de nuvem do Ollama (`:cloud`), o código lido pelo agente sai da máquina.
+
+## Segurança
+
+- O servidor só escuta em `127.0.0.1`.
+- Toda chamada à API exige o token aleatório que vai na URL (`?t=…`), gerado a cada execução. Outro
+  site aberto no navegador não consegue disparar o agente.
+- Um comando do ambiente por vez: enquanto um roda, os outros são recusados.
+- A resposta do modelo aparece como Markdown, sem HTML, sem imagens e sem links que não sejam http(s).
+
+## Instalação a partir do código
+
+```bash
+git clone git@github.com:vitortrack/djinnai.git
+cd djinnai
+bash ./djinn.sh install     # npm ci + build da tela + npm link + autocompletar do bash
+```
+
+| Comando | O que faz |
+|---|---|
+| `bash ./djinn.sh update` | O mesmo que `install`, depois de um `git pull` |
+| `bash ./djinn.sh uninstall` | Remove o link global e o autocompletar |
+| `npm run build` | Gera `web/dist`, que é o que o pacote publica |
+| `npm test` | Checa o Markdown (sem HTML nem links perigosos) e como a tela monta a conversa a partir dos eventos |
+
+A tela é React + Vite e usa componentes do [React Bits](https://reactbits.dev) (PromptBar,
+ThoughtLine, LatticeLoader, StatusMark, RubberSegment), copiados para `web/src/components/`. O
+servidor (`server.js`) usa só a biblioteca padrão do Node; a única dependência do pacote é o Electron,
+que desenha a janela (`window.cjs`).

package/djinn-completion.bash

@@ -0,0 +1,9 @@
+# Autocomplete Bash do DjinnAI.
+
+_djinn_completion() {
+    if [[ ${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "start restart rebuild logs status stop clean execute hot-reload auto-remove worker help version" -- "${COMP_WORDS[1]}"))
+    fi
+}
+
+complete -F _djinn_completion djinn djinnai

package/djinn.sh

@@ -0,0 +1,246 @@
+#!/usr/bin/env bash
+
+set -Eeuo pipefail
+
+readonly CLI_NAME="djinn"
+readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+readonly PACKAGE_FILE="${SCRIPT_DIR}/package.json"
+readonly PACKAGE_LOCK_FILE="${SCRIPT_DIR}/package-lock.json"
+readonly INDEX_FILE="${SCRIPT_DIR}/index.js"
+readonly COMPLETION_SOURCE="${SCRIPT_DIR}/djinn-completion.bash"
+
+readonly COMPLETION_DIR="${HOME}/.local/share/bash-completion/completions"
+readonly COMPLETION_FILE="${COMPLETION_DIR}/${CLI_NAME}"
+readonly BASHRC_FILE="${HOME}/.bashrc"
+
+readonly BASHRC_MARKER_START="# >>> DJINNAI >>>"
+readonly BASHRC_MARKER_END="# <<< DJINNAI <<<"
+
+info() {
+    printf '\033[1;36m%s\033[0m\n' "$1"
+}
+
+success() {
+    printf '\033[1;32m%s\033[0m\n' "$1"
+}
+
+warning() {
+    printf '\033[1;33m%s\033[0m\n' "$1"
+}
+
+error() {
+    printf '\033[1;31mErro: %s\033[0m\n' "$1" >&2
+}
+
+die() {
+    error "$1"
+    exit 1
+}
+
+on_error() {
+    local exit_code=$?
+    local line_number="${1:-desconhecida}"
+
+    error "A instalação falhou na linha ${line_number}."
+    exit "${exit_code}"
+}
+
+trap 'on_error "$LINENO"' ERR
+
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+validate_environment() {
+    command_exists node || die "Node.js não está instalado."
+    command_exists npm || die "npm não está instalado."
+
+    [[ -f "${PACKAGE_FILE}" ]] ||
+        die "Arquivo não encontrado: ${PACKAGE_FILE}"
+
+    [[ -f "${INDEX_FILE}" ]] ||
+        die "Arquivo não encontrado: ${INDEX_FILE}"
+
+    [[ -f "${COMPLETION_SOURCE}" ]] ||
+        die "Arquivo não encontrado: ${COMPLETION_SOURCE}"
+}
+
+ensure_permissions() {
+    chmod +x "${INDEX_FILE}"
+    chmod +x "${SCRIPT_DIR}/djinn.sh"
+}
+
+install_dependencies() {
+    info "Instalando dependências..."
+
+    cd "${SCRIPT_DIR}"
+
+    if [[ -f "${PACKAGE_LOCK_FILE}" ]]; then
+        npm ci --no-audit --no-fund
+    else
+        npm install --no-audit --no-fund
+    fi
+
+    info "Gerando a tela web..."
+    npm run build
+}
+
+install_cli() {
+    info "Registrando comando ${CLI_NAME}..."
+    cd "${SCRIPT_DIR}"
+    npm link
+}
+
+install_completion() {
+    info "Instalando autocomplete..."
+
+    mkdir -p "${COMPLETION_DIR}"
+
+    install \
+        -m 0644 \
+        "${COMPLETION_SOURCE}" \
+        "${COMPLETION_FILE}"
+}
+
+remove_old_bashrc_configuration() {
+    [[ -f "${BASHRC_FILE}" ]] || return 0
+
+    local temporary_file
+    temporary_file="$(mktemp)"
+
+    awk \
+        -v start="${BASHRC_MARKER_START}" \
+        -v end="${BASHRC_MARKER_END}" \
+        '
+        $0 == start {
+            removing = 1
+            next
+        }
+
+        $0 == end {
+            removing = 0
+            next
+        }
+
+        !removing {
+            print
+        }
+        ' "${BASHRC_FILE}" > "${temporary_file}"
+
+    mv "${temporary_file}" "${BASHRC_FILE}"
+}
+
+configure_bashrc() {
+    info "Configurando o Bash..."
+
+    touch "${BASHRC_FILE}"
+
+    remove_old_bashrc_configuration
+
+    cat >> "${BASHRC_FILE}" <<EOF
+
+${BASHRC_MARKER_START}
+if [[ -f "${COMPLETION_FILE}" ]]; then
+    source "${COMPLETION_FILE}"
+fi
+${BASHRC_MARKER_END}
+EOF
+}
+
+verify_installation() {
+    hash -r
+
+    local installed_cli
+
+    installed_cli="$(command -v "${CLI_NAME}" 2>/dev/null || true)"
+
+    if [[ -z "${installed_cli}" ]]; then
+        warning "A CLI foi instalada, mas o comando ainda não apareceu no PATH atual."
+        warning "Abra um novo terminal para atualizar o ambiente."
+        return 0
+    fi
+
+    success "CLI disponível em: ${installed_cli}"
+}
+
+uninstall_cli() {
+    info "Removendo DjinnAI..."
+
+    cd "${SCRIPT_DIR}"
+
+    npm unlink --global "${CLI_NAME}" >/dev/null 2>&1 ||
+        npm unlink --global >/dev/null 2>&1 ||
+        true
+
+    rm -f "${COMPLETION_FILE}"
+
+    remove_old_bashrc_configuration
+
+    success "DjinnAI removida."
+    warning "Abra um novo terminal para concluir a atualização do ambiente."
+}
+
+show_help() {
+    cat <<EOF
+Uso:
+
+  bash ./djinn.sh
+  bash ./djinn.sh install
+  bash ./djinn.sh update
+  bash ./djinn.sh uninstall
+  bash ./djinn.sh help
+
+Comandos:
+
+  install     Instala a CLI e o autocomplete
+  update      Atualiza a instalação existente
+  uninstall   Remove a CLI e o autocomplete
+  help        Exibe esta ajuda
+
+Sem argumentos, o comando executado será "install".
+EOF
+}
+
+install_all() {
+    validate_environment
+    ensure_permissions
+    install_dependencies
+    install_cli
+    install_completion
+    configure_bashrc
+    verify_installation
+
+    echo
+    success "DjinnAI instalada com sucesso."
+    echo
+    printf 'Use:\n'
+    printf '  %s\n' "${CLI_NAME}"
+    printf '  %s restart\n' "${CLI_NAME}"
+    printf '  %s logs\n' "${CLI_NAME}"
+    echo
+    warning "O autocomplete estará disponível automaticamente nos próximos terminais."
+}
+
+main() {
+    local action="${1:-install}"
+
+    case "${action}" in
+        install|update)
+            install_all
+            ;;
+
+        uninstall|remove)
+            uninstall_cli
+            ;;
+
+        help|-h|--help)
+            show_help
+            ;;
+
+        *)
+            die "Comando desconhecido: ${action}. Use: bash ./djinn.sh help"
+            ;;
+    esac
+}
+
+main "$@"

package/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { startServer } from './server.js';
+
+function findProjectRoot(start) {
+  for (const marker of ['.djinn', '.detro', '.git', 'package.json']) {
+    for (let dir = start; ; dir = path.dirname(dir)) {
+      if (existsSync(path.join(dir, marker))) return dir;
+      if (path.dirname(dir) === dir) break;
+    }
+  }
+  return start;
+}
+
+const projectDir = findProjectRoot(process.cwd());
+const appScript = [process.env.DJINN_APP_SCRIPT ?? process.env.DETRO_APP_SCRIPT, 'appDev', 'app']
+  .filter(Boolean)
+  .map((name) => path.resolve(projectDir, name))
+  .find((file) => existsSync(file)) ?? path.join(projectDir, 'appDev');
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const QUICK_EXIT_MS = 3000;
+const { version } = JSON.parse(readFileSync(path.join(HERE, 'package.json'), 'utf8'));
+
+function openBrowser(url) {
+  const opener = { darwin: ['open'], win32: ['cmd', '/c', 'start', ''] }[process.platform] ?? ['xdg-open'];
+  spawn(opener[0], [...opener.slice(1), url], { stdio: 'ignore', detached: true }).on('error', () => {}).unref();
+}
+
+function sandboxFlags(electron) {
+  if (process.platform !== 'linux') return [];
+  try {
+    const { uid, mode } = statSync(path.join(path.dirname(electron), 'chrome-sandbox'));
+    if (uid === 0 && mode & 0o4000) return [];
+  } catch {}
+  return ['--no-sandbox'];
+}
+
+async function openAppWindow(url, onClose) {
+  const electron = await import('electron').then((module) => module.default, () => null);
+  let fellBack = false;
+  const fallback = () => {
+    if (fellBack) return;
+    fellBack = true;
+    console.log('Não consegui abrir a janela do aplicativo; abrindo no navegador.');
+    openBrowser(url);
+  };
+  if (!electron) return fallback();
+  const startedAt = Date.now();
+  const { ELECTRON_RUN_AS_NODE, ...env } = process.env;
+  const window = spawn(electron, [...sandboxFlags(electron), path.join(HERE, 'window.cjs'), url], { stdio: 'ignore', env });
+  window.on('error', fallback);
+  window.on('exit', () => (Date.now() - startedAt < QUICK_EXIT_MS ? fallback() : onClose()));
+  return window;
+}
+
+const args = process.argv.slice(2);
+
+if (['version', '--version', '-v'].includes(args[0])) {
+  console.log(`DjinnAI ${version}`);
+} else if (args.length > 0 && args[0] !== '--navegador') {
+  spawn(appScript, args, { cwd: projectDir, stdio: 'inherit' })
+    .on('error', (error) => {
+      console.error(`Não foi possível executar ${appScript} (${error.message}). Confira se ele existe e é executável (chmod +x).`);
+      process.exit(1);
+    })
+    .on('close', (code) => process.exit(code ?? 1));
+} else {
+  const { url, close } = await startServer({ projectDir, appScript, version, port: Number(process.env.DJINN_PORT ?? process.env.DETRO_PORT) || 0 }).catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+  console.log(`DjinnAI ${version} — ${projectDir}\n\n  ${url}\n\nAbra o endereço no navegador se quiser acompanhar por lá também. Feche a janela ou use Ctrl+C para encerrar.`);
+  const quit = () => {
+    close();
+    process.exit(0);
+  };
+  const window = args[0] === '--navegador' ? openBrowser(url) : await openAppWindow(url, quit);
+  process.on('SIGINT', () => {
+    window?.kill();
+    quit();
+  });
+}

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@vitortrack777/djinnai",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.6.0",
+  "description": "DjinnAI: aplicativo local para conversar com o agente do Claude Code (Claude ou modelos do Ollama) e rodar os comandos do ambiente do projeto.",
+  "type": "module",
+  "bin": {
+    "djinn": "./index.js",
+    "djinnai": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "node web/src/lib/markdown.test.js && node web/src/lib/turns.test.js",
+    "build": "vite build --config web/vite.config.js",
+    "prepublishOnly": "npm run build",
+    "setup": "bash ./djinn.sh install",
+    "update": "bash ./djinn.sh update",
+    "uninstall-cli": "bash ./djinn.sh uninstall"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.12"
+  },
+  "files": [
+    "index.js",
+    "server.js",
+    "window.cjs",
+    "web/dist/",
+    "djinn.sh",
+    "djinn-completion.bash",
+    "LICENSE"
+  ],
+  "keywords": [
+    "djinnai",
+    "djinn",
+    "cli",
+    "ai",
+    "claude",
+    "claude-code",
+    "ollama",
+    "agent"
+  ],
+  "author": "vitortrack",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitortrack/djinnai.git"
+  },
+  "homepage": "https://github.com/vitortrack/djinnai#readme",
+  "bugs": {
+    "url": "https://github.com/vitortrack/djinnai/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@hugeicons/core-free-icons": "^4.3.5",
+    "@hugeicons/react": "^1.1.10",
+    "@vitejs/plugin-react": "^4.7.0",
+    "marked": "^15.0.12",
+    "motion": "^12.43.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "vite": "^6.4.5"
+  },
+  "dependencies": {
+    "electron": "44.7.1"
+  }
+}