create-writerkit 1.0.0

package/livro-final/venv/lib/python3.12/site-packages/pip-24.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

package/livro-final/venv/lib/python3.12/site-packages/pip-24.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main
+pip3.12 = pip._internal.cli.main:main

package/livro-final/venv/lib/python3.12/site-packages/pip-24.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pip

package/livro-final/venv/pyvenv.cfg

@@ -0,0 +1,5 @@
+home = /usr/bin
+include-system-site-packages = false
+version = 3.12.3
+executable = /usr/bin/python3.12
+command = /usr/bin/python3 -m venv /home/sekeff/PROJECTS/writerkit-project/livro-final/venv

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "create-writerkit",
+  "version": "1.0.0",
+  "description": "CLI para inicializar projetos de livros técnicos em LaTeX com o WriterKit",
+  "main": "bin/cli.js",
+  "type": "module",
+  "bin": {
+    "create-writerkit": "./bin/cli.js"
+  },
+  "keywords": [
+    "writerkit",
+    "latex",
+    "gemini",
+    "antigravity",
+    "cli"
+  ],
+  "author": "Ricardo Sekeff",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0"
+  }
+}

package/skills/writerkit-init/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: writerkit-init
+description: Use when the user wants to start, plan, write, or publish technical and scientific books in LaTeX, requiring end-to-end orchestration of the production lifecycle.
+metadata:
+  triggers: technical books, LaTeX, scientific writing, book production, academic references
+---
+
+# Producing Technical Books (WriterKit)
+
+## Overview
+This skill orchestrates the full lifecycle of technical book production, from initial setup and planning to final publication. It manages a sequence of specialized sub-skills to ensure academic rigor, technical accuracy, and LaTeX compatibility.
+
+## When to Use This Skill
+- Starting a new technical or scientific book project.
+- Producing a complete chapter following a structured workflow.
+- Ensuring code examples are correctly rendered in LaTeX (accent mapping).
+- Validating academic references against real-world databases.
+
+## How to Use It
+The workflow is divided into 8 mandatory phases. **Phase 0 is required once per project.**
+
+0. **Initialization** (`writerkit-init`): **MANDATORY FIRST STEP.** 
+   - Copy the `/home/sekeff/.gemini/antigravity/skills/writerkit-init/memory/` directory to the local project root as `./memory/`.
+   - Create the following project structure:
+     - `./chapters`: For chapter `.tex` files.
+     - `./codes`: For code snippet `.tex` files, organized by `./codes/chapterxx/`.
+     - `./images`: For `png`, `svg`, and `tikz` files, organized by `./images/chapterxx/`.
+     - `./fonts`: For custom font files (defaults to LaTeX fonts if empty).
+     - `./configs`: For `.cls` and `.sty` configuration files.
+     - `./templates`: For user-provided template models.
+     - `./output`: To hold the final compilable structure for TexPage.
+   - Initialize a `main.tex` in the root with capa, TOC, and basic imports.
+1. **Setup** (`/writer-setup`): Initialize project and editorial pillars in `./memory/memory.json`.
+2. **Planning** (`/writer-planning`): Outline chapter goals and structure.
+3. **Drafting** (`/writer-drafting`): Generate conceptual content in LaTeX.
+4. **Code Development** (`/writer-code`): Implement and map accents for algorithms.
+5. **Integration** (`/writer-integration`): Consolidate text, code, and TikZ diagrams.
+6. **Review** (`/writer-review`): Perform pedagogical and technical peer-review.
+7. **Validation** (`/writer-validation`): Run structural checks and reference validation.
+8. **Revision** (`/writer-revision`): Refactor based on feedback.
+9. **Publication** (`/writer-publication`): Finalize LaTeX for TexPage.
+
+### Mandatory Rules
+- **Structural Integrity:** ALWAYS follow the defined folder schema. Never place assets outside their designated directories.
+- **Progressive Loading:** Activate the specific sub-skill for each phase.
+- **Local Project Memory:** All state and decisions MUST be recorded in the local `./memory/memory.json` file. NEVER write to the global skill path.
+- **Decision Logging:** Every transition and decision must be recorded in `./memory/memory.json`.
+- **Main File Logic:** `main.tex` must be the orchestrator of the book, importing styles from `./configs` and chapters from `./chapters`.
+- **Accent Mapping:** Always ensure `literate` mapping for non-ASCII characters in code blocks.
+- **Reference Integrity:** Use the Reference Checker script during the Validation phase.

package/skills/writerkit-init/memory/memory.json

@@ -0,0 +1,16 @@
+{
+  "project": {
+    "title": "Ainda Não Definido",
+    "tone": "Pendente",
+    "language": "Pendente",
+    "code_language": "Pendente",
+    "bibliography_standard": "Pendente",
+    "status": "Ready for Setup",
+    "latex_template": "Pendente"
+  },
+  "latex_config": {
+    "listings_literate": ""
+  },
+  "chapters": [],
+  "decision_log": []
+}

package/skills/writerkit-init/memory/schema.md

@@ -0,0 +1,18 @@
+# Módulo de Memória e Estado
+
+O arquivo de memória (ex: `memory.json`) deve ser mantido e atualizado constantemente pelas *skills*.
+
+## Estrutura de Metadados do Projeto
+* **`title`**: Título da obra.
+* **`theme`**: Tema central e escopo.
+* **`language`**: Idioma da obra (ex: pt-BR).
+* **`depth`**: Nível de profundidade (Graduação, Mestrado, Técnico).
+* **`rigor`**: Nível de formalismo matemático/teórico.
+* **`tone`**: Personalidade do texto (Formal, Professoral, Crítico).
+* **`code_style`**: Linguagem e guia de estilo de código.
+* **`visual_style`**: Padrão para imagens e diagramas (ex: TikZ, preto e branco).
+* **`latex_template`**: Referências aos arquivos `.tex`, `.cls` e `.sty` utilizados.
+
+## Logs e Controle
+* **`chapters`**: Status e metadados de cada capítulo.
+* **`decision_log`**: Histórico temporal (timestamps) de todas as decisões tomadas.

package/skills/writerkit-init/resources/checklists.md

@@ -0,0 +1,28 @@
+# Padrão de Checklist para Produção de Capítulos
+
+Durante as etapas de **Review** e **Validation**, o agente deve percorrer rigorosamente o checklist abaixo e registrar o resultado na memória.
+
+## 1. Technical Accuracy (Precisão Técnica)
+- [ ] Os exemplos de código foram validados externamente e estão corretos?
+- [ ] As explicações conceituais estão em conformidade com o estado da arte e o rigor matemático exigido?
+- [ ] O uso de APIs/Bibliotecas nos exemplos condiz com a versão mais recente/estável suportada pelo projeto?
+
+## 2. Consistency (Consistência)
+- [ ] A terminologia técnica é uniforme ao longo de todo o capítulo e consistente com os capítulos anteriores?
+- [ ] O estilo de formatação do código (identação, convenção de nomes) segue o `code_style` definido na memória?
+- [ ] O mapeamento de acentuação (literate) no LaTeX está implementado corretamente nos blocos de código?
+
+## 3. Readability (Legibilidade e Fluidez)
+- [ ] O texto possui cadência lógica (introdução, desenvolvimento, conclusão parcial) sem saltos bruscos?
+- [ ] A linguagem está adequada ao tom estabelecido na memória?
+- [ ] Os parágrafos são coesos e evitam jargões desnecessários quando não explicados previamente?
+
+## 4. Completeness (Completude)
+- [ ] Os pré-requisitos lógicos para a compreensão do capítulo foram declarados?
+- [ ] Os objetivos de aprendizagem traçados na fase de *Planning* foram integralmente alcançados?
+- [ ] Há uma seção de fechamento/resumo que consolida o conhecimento adquirido?
+
+## 5. Cross-references (Referências e Navegação)
+- [ ] Todos os *labels* e *refs* internos (imagens, tabelas, algoritmos) foram validados e não apontam para locais nulos?
+- [ ] Todas as citações bibliográficas (\cite) correspondem a uma entrada válida no arquivo BibTeX?
+- [ ] **Validação Externa:** Todas as referências bibliográficas foram verificadas com sucesso em bases acadêmicas (Google Scholar, ScienceDirect, IEEE, etc.)?

package/skills/writerkit-init/resources/tools.json

@@ -0,0 +1,14 @@
+{
+  "tools": [
+    {
+      "name": "update_memory",
+      "description": "Updates the local project state in ./memory/memory.json",
+      "execute": "cat > ./memory/memory.json"
+    },
+    {
+      "name": "check_references",
+      "description": "Verifies the real-world existence of scientific articles",
+      "execute": "python3 /home/sekeff/.gemini/antigravity/skills/writerkit-init/scripts/reference_checker.py"
+    }
+  ]
+}

package/skills/writerkit-init/scripts/reference_checker.py

@@ -0,0 +1,49 @@
+import re
+import urllib.request
+import urllib.error
+import urllib.parse
+import json
+from typing import Dict
+
+# SCRIPT DE VALIDAÇÃO DE REFERÊNCIAS (Reference Checker)
+# Objetivo: Garantir a veracidade de artigos citados no livro, prevenindo alucinações da IA.
+
+def check_paper_existence(title: str, first_author: str = "") -> bool:
+    base_url = "https://api.crossref.org/works?"
+    query_params = {"query.title": title, "rows": 3}
+    if first_author:
+        query_params["query.author"] = first_author
+        
+    url = base_url + urllib.parse.urlencode(query_params)
+    
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'WriterKit-Antigravity/1.0'})
+        with urllib.request.urlopen(req) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                items = data.get("message", {}).get("items", [])
+                if items:
+                    return True
+                return False
+    except urllib.error.URLError as e:
+        print(f"Erro ao acessar CrossRef: {e}")
+        return False
+
+def validate_bibtex(bibtex_content: str) -> Dict[str, str]:
+    results = {}
+    entries = bibtex_content.split("@")
+    for entry in entries[1:]:
+        title_match = re.search(r'title\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        author_match = re.search(r'author\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        id_match = re.search(r'^[^\{]+\{([^,]+),', entry)
+        
+        if title_match and id_match:
+            ref_id = id_match.group(1).strip()
+            title = title_match.group(1).strip()
+            author = author_match.group(1).split(' and ')[0].strip() if author_match else ""
+            
+            print(f"Verificando referência [{ref_id}]: {title}...")
+            is_valid = check_paper_existence(title, author)
+            results[ref_id] = "VERIFICADA_E_VALIDA" if is_valid else "FALHA_NA_VERIFICACAO"
+            
+    return results

package/skills/writerkit-planning/SKILL.md

@@ -0,0 +1,18 @@
+name: writerkit-planning
+description: Use when the user asks to plan, structure, or define the learning objectives and pedagogical outline for a new technical book chapter.
+metadata:
+  triggers: chapter planning, learning objectives, pedagogical outline, book structure, chapter scope
+---
+
+# Planning Chapter
+
+## When to Use This Skill
+- Defining the scope of a new chapter.
+- Creating a pedagogical outline (H1, H2, H3).
+- Identifying where code examples and diagrams should be placed.
+
+## How to Use It
+1. **Review Book Metadata:** Load project goals from `./memory/memory.json`.
+2. **Generate Outline:** Create a detailed structure including conceptual sections, code snippets, and TikZ illustrations.
+3. **Set Learning Objectives:** Define what the student/reader should master by the end of the chapter.
+4. **Save Plan:** Record the approved outline in the project memory.

package/skills/writerkit-setup/SKILL.md

@@ -0,0 +1,26 @@
+name: writerkit-setup
+description: Use when the user wants to initialize a new technical book project, establish editorial standards, or configure LaTeX environment pillars.
+metadata:
+  triggers: project setup, editorial pillars, LaTeX configuration, template analysis, project initialization
+---
+
+# Setting Up Kit
+
+## When to Use This Skill
+- Initializing a new project using the WriterKit framework.
+- Configuring tone, language, and coding standards for a book.
+- Setting up the LaTeX environment for TexPage compatibility.
+
+## How to Use It
+1. **Analyze Templates (Strict Mapping):**
+   - Inspect provided `.tex`, `.cls`, and `.sty` files.
+   - **Crucial:** Map ALL available commands, environments, and functions defined in these files.
+   - **Crucial:** Map ALL defined colors from the color scheme files or preamble.
+   - Extract preamble requirements.
+2. **Conduct Configuration Interview:** Ask the Professor (User) to confirm:
+   - **Tone:** (e.g., Formal, Professoral).
+   - **Language:** (e.g., pt-BR).
+   - **Primary Programming Language:** For syntax highlighting and accent mapping.
+   - **Reference Style:** (e.g., ABNT, IEEE).
+3. **Map Characters:** Configure the `literate` dictionary for the `listings` package to handle accented characters in code.
+4. **Persist State:** Save all configurations, including the **mapped commands/environments and colors**, to `./memory/memory.json` and log the completion in the `decision_log`.

package/src/checkEnvironment.js

@@ -0,0 +1,36 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import chalk from 'chalk';
+
+export function checkEnvironment(projectPath) {
+  console.log(chalk.blue(`\n🐍 A verificar as dependências do sistema...`));
+
+  try {
+    // Tenta executar o comando python3
+    let pythonCmd = 'python3';
+    
+    try {
+      execSync(`${pythonCmd} --version`, { stdio: 'ignore' });
+    } catch (err) {
+      // Fallback para 'python' caso no Windows esteja mapeado apenas como python
+      pythonCmd = 'python';
+      execSync(`${pythonCmd} --version`, { stdio: 'ignore' });
+    }
+
+    const pythonVersion = execSync(`${pythonCmd} --version`).toString().trim();
+    console.log(chalk.green(`   ✅ Python detetado: ${pythonVersion}`));
+
+    // Caminho para o novo ambiente virtual dentro do projeto do livro
+    const venvPath = path.join(projectPath, 'venv');
+    console.log(chalk.blue(`   📦 A preparar o ambiente virtual em ./venv...`));
+    
+    // Cria o ambiente virtual
+    execSync(`${pythonCmd} -m venv "${venvPath}"`);
+    console.log(chalk.green(`   ✅ Ambiente virtual criado com sucesso.`));
+
+  } catch (error) {
+    // Se falhar, avisa o utilizador, mas não impede a criação do projeto
+    console.log(chalk.yellow(`   ⚠️ Aviso: O Python 3 não foi detetado no seu sistema.`));
+    console.log(chalk.yellow(`      A validação de referências (reference_checker.py) requer o Python para funcionar.`));
+  }
+}

package/src/injectSkills.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+// Configuração necessária para usar __dirname em módulos ES (type: "module")
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function injectSkills() {
+  console.log(chalk.blue(`\n📦 A iniciar a injeção de skills no Antigravity...`));
+
+  // 1. Caminho de origem: a pasta 'skills' que está dentro do nosso pacote npm
+  const sourceSkillsPath = path.join(__dirname, '..', 'skills');
+
+  // 2. Caminho de destino: encontrar a pasta Home (os.homedir()) do utilizador 
+  // Funciona em Windows (C:\Users\Nome), macOS (/Users/Nome) e Linux (/home/nome)
+  const targetAntigravityPath = path.join(os.homedir(), '.gemini', 'antigravity', 'skills', 'writerkit');
+
+  // Verifica se a pasta 'skills' existe no instalador para evitar erros
+  if (!fs.existsSync(sourceSkillsPath)) {
+    console.log(chalk.yellow(`   ⚠️ Aviso: A pasta 'skills' não foi encontrada no seu instalador original. A injeção foi ignorada.`));
+    return;
+  }
+
+  // 3. Garante que a árvore de diretórios de destino existe. Se não existir, cria-a.
+  if (!fs.existsSync(targetAntigravityPath)) {
+    fs.mkdirSync(targetAntigravityPath, { recursive: true });
+  }
+
+  // 4. Copia os ficheiros de forma recursiva da origem para o destino
+  try {
+    // cpSync com recursive: true requer Node.js v16.7.0 ou superior
+    fs.cpSync(sourceSkillsPath, targetAntigravityPath, { recursive: true });
+    console.log(chalk.green(`   ✅ Skills injetadas com sucesso em: ${targetAntigravityPath}`));
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao injetar as skills: ${error.message}`));
+  }
+}

package/src/orchestrator.js

@@ -0,0 +1,79 @@
+import { exec } from 'child_process';
+import util from 'util';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+// Permite usar chamadas de terminal de forma assíncrona (Promises)
+const execAsync = util.promisify(exec);
+
+export async function runMultiAgentPipeline(projectPath, chapterTopic) {
+  console.log(chalk.blue(`\n🚀 Iniciando a orquestração multi-agente para: "${chapterTopic}"...`));
+
+  // 1. CARREGAR A MEMÓRIA DO PROJETO
+  const memoryPath = path.join(projectPath, 'memory', 'memory.json');
+  let memory;
+  try {
+    const memoryData = fs.readFileSync(memoryPath, 'utf8');
+    memory = JSON.parse(memoryData);
+    console.log(chalk.gray(`   📖 Memória carregada. Status atual: ${memory.project.status}`));
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao ler memory.json. O orquestrador foi abortado.`));
+    return;
+  }
+
+  try {
+    console.log(chalk.yellow(`   ⏳ O Agente Redator e o Agente Pesquisador estão trabalhando em paralelo...\n`));
+
+    // 2. DISPARAR OS AGENTES EM PARALELO
+    // OBS: Substitua os comandos "echo" pelos comandos reais do Gemini CLI e do seu Python no futuro.
+    const draftingCommand = `echo "Texto gerado via Gemini CLI para o tópico: ${chapterTopic}"`;
+    const researchCommand = `python3 ${path.join(projectPath, 'venv', 'bin', 'python')} -c "print('Validação de referências concluída com sucesso.')"`;
+
+    const draftingTask = execAsync(draftingCommand);
+    const researchTask = execAsync(researchCommand);
+
+    // O código pausa aqui e aguarda ambos finalizarem
+    const [draftResult, researchResult] = await Promise.all([draftingTask, researchTask]);
+
+    console.log(chalk.green(`   ✅ Ambos os agentes concluíram suas tarefas!`));
+    console.log(chalk.cyan(`\n--- Output do Agente Pesquisador ---`));
+    console.log(researchResult.stdout.trim());
+
+    // 3. ATUALIZAR A MEMÓRIA COM OS RESULTADOS
+    // Registramos a decisão e a ação no log cronológico para que a IA tenha contexto futuro
+    const timestamp = new Date().toISOString();
+    
+    memory.decision_log.push({
+      timestamp: timestamp,
+      phase: "Drafting & Research (Paralelo)",
+      topic: chapterTopic,
+      status: "SUCCESS",
+      notes: "O Agente Redator e Pesquisador concluíram a execução sem conflitos."
+    });
+
+    // Atualiza os capítulos na memória
+    memory.chapters.push({
+      title: chapterTopic,
+      status: "Drafted",
+      validation: "Approved"
+    });
+
+    // 4. SALVAR A MEMÓRIA ATUALIZADA
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+    console.log(chalk.green(`   💾 memory.json atualizado com o histórico da operação.`));
+
+  } catch (error) {
+    console.error(chalk.red(`\n   ❌ Ocorreu um erro crítico em um dos agentes: ${error.message}`));
+    
+    // Em caso de erro, também registramos na memória para o loop de autocorreção agir depois
+    memory.decision_log.push({
+      timestamp: new Date().toISOString(),
+      phase: "Drafting & Research",
+      topic: chapterTopic,
+      status: "FAILED",
+      error_log: error.message
+    });
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+  }
+}

package/teste-injecao/main.tex

@@ -0,0 +1,62 @@
+\documentclass[12pt,a4paper]{report}
+
+% --- Pacotes Básicos (Imports) ---
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[brazilian]{babel}
+\usepackage{graphicx}
+\usepackage{amsmath,amssymb}
+\usepackage{hyperref}
+\usepackage{listings}
+\usepackage{booktabs}
+\usepackage{geometry}
+\geometry{a4paper, margin=2.5cm}
+
+% --- Configurações de Código (listings) ---
+\lstset{
+    basicstyle=\ttfamily\small,
+    numbers=left,
+    numberstyle=\tiny,
+    stepnumber=1,
+    numbersep=5pt,
+    backgroundcolor=\color{gray!10},
+    showspaces=false,
+    showstringspaces=false,
+    showtabs=false,
+    frame=single,
+    tabsize=2,
+    captionpos=b,
+    breaklines=true,
+    breakatwhitespace=true,
+    escapeinside={\%*}{*)}
+}
+
+% --- Capa (Capa e Folha de Rosto) ---
+\title{Ainda Não Definido}
+\author{Autor}
+\date{\today}
+
+\begin{document}
+
+% --- Capa Customizada ---
+\begin{titlepage}
+    \centering
+    \vspace*{2cm}
+    {\huge \bfseries Ainda Não Definido \par}
+    \vspace{1.5cm}
+    {\large \bfseries Autor \par}
+    \vfill
+    {\large Cidade, País \par}
+    {\large \today \par}
+\end{titlepage}
+
+% --- Elementos Pré-Textuais ---
+\maketitle
+\tableofcontents
+
+\newpage
+
+% --- Capítulos (Serão importados de ./chapters) ---
+% Exemplo: \include{chapters/capitulo01}
+
+\end{document}

package/teste-injecao/memory/memory.json

@@ -0,0 +1,22 @@
+{
+  "project": {
+    "title": "Ainda Não Definido",
+    "tone": "Pendente",
+    "language": "Pendente",
+    "code_language": "Pendente",
+    "bibliography_standard": "Pendente",
+    "status": "Ready for Setup",
+    "latex_template": "Pendente"
+  },
+  "latex_config": {
+    "listings_literate": ""
+  },
+  "chapters": [],
+  "decision_log": [
+    {
+      "timestamp": "2026-07-06T21:41:40-03:00",
+      "phase": "0. Initialization",
+      "action": "writerkit-init activated, folder structure verified, memory templates copied, main.tex initialized with cover page and imports."
+    }
+  ]
+}

package/teste-injecao/memory/schema.md

@@ -0,0 +1,18 @@
+# Módulo de Memória e Estado
+
+O arquivo de memória (ex: `memory.json`) deve ser mantido e atualizado constantemente pelas *skills*.
+
+## Estrutura de Metadados do Projeto
+* **`title`**: Título da obra.
+* **`theme`**: Tema central e escopo.
+* **`language`**: Idioma da obra (ex: pt-BR).
+* **`depth`**: Nível de profundidade (Graduação, Mestrado, Técnico).
+* **`rigor`**: Nível de formalismo matemático/teórico.
+* **`tone`**: Personalidade do texto (Formal, Professoral, Crítico).
+* **`code_style`**: Linguagem e guia de estilo de código.
+* **`visual_style`**: Padrão para imagens e diagramas (ex: TikZ, preto e branco).
+* **`latex_template`**: Referências aos arquivos `.tex`, `.cls` e `.sty` utilizados.
+
+## Logs e Controle
+* **`chapters`**: Status e metadados de cada capítulo.
+* **`decision_log`**: Histórico temporal (timestamps) de todas as decisões tomadas.