@v-aranda/artifice 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artifice Team
+
+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

@@ -0,0 +1,39 @@
+# Artifice CLI
+
+CLI para iniciar a etapa de exploração de um projeto com Gemini Notebook Enterprise.
+
+## Instalação
+
+### Linux (x64)
+
+```bash
+curl -fsSL https://github.com/v-aranda/Artifice/releases/latest/download/install.sh | bash
+```
+
+O instalador valida o checksum e instala o executável em `~/.local/bin`, sem precisar de Node.js ou permissões de administrador.
+
+### Windows (x64)
+
+[Baixar Artifice para Windows](https://github.com/v-aranda/Artifice/releases/latest/download/Artifice-Setup-x64.exe)
+
+O instalador adiciona o Artifice ao `PATH` do usuário. Durante a fase beta, o executável ainda não possui assinatura de código e o Windows pode exibir um alerta do SmartScreen.
+
+### npm (desenvolvedores)
+
+```bash
+npm install --global @v-aranda/artifice
+```
+
+## Uso
+
+```bash
+artifice explore
+```
+
+`artifice explore` configura a autenticação Google, cria o notebook vinculado ao projeto e inclui aqui o link de acesso. O projeto Google Cloud precisa ter o Gemini Notebook Enterprise configurado, licenças atribuídas e permissões IAM adequadas.
+
+Para acrescentar uma fonte web ao notebook vinculado:
+
+```bash
+artifice source https://example.com --name "Referência"
+```

package/bin/artifice.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import chalk from 'chalk';
+import { runExplore } from './explore.js';
+import { configureGoogleAuth } from '../src/auth/google-auth.js';
+import { addWebSource } from '../src/notebooklm/client.js';
+import { getProjectNotebook } from '../src/utils/project-config.js';
+
+program.name('artifice').description('CLI para scaffolding e orquestração de agentes de IA').version('1.0.0');
+program.command('explore').description('Cria e configura o notebook do projeto.').option('--force', 'Substitui o vínculo local existente.').action(async (options) => runExplore(options));
+program.command('auth').description('Configura ou renova a autenticação Google.').action(async () => { await configureGoogleAuth(); console.log(chalk.green('✓ Credenciais armazenadas em ~/.artificerc')); });
+program.command('source <url>').description('Adiciona uma URL como fonte ao notebook do projeto.').option('-n, --name <name>', 'Nome exibido da fonte').action(async (url, options) => {
+  try { new URL(url); } catch { throw new Error('A fonte deve ser uma URL válida.'); }
+  const notebook = getProjectNotebook();
+  if (!notebook) throw new Error('Nenhum notebook vinculado. Execute "artifice explore" primeiro.');
+  await addWebSource(notebook, url, options.name || url);
+  console.log(chalk.green('✓ Fonte adicionada ao notebook.'));
+});
+program.parseAsync(process.argv).catch((error) => { console.error(chalk.red(`\n✗ ${error.message}`)); process.exitCode = 1; });

package/bin/explore.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { createNotebook } from '../src/notebooklm/client.js';
+import { getProjectNotebook, saveProjectNotebook } from '../src/utils/project-config.js';
+
+function writeReadmeLink(notebook, cwd) {
+  const file = path.join(cwd, 'README.md');
+  const marker = '<!-- artifice:notebook -->';
+  const endMarker = '<!-- /artifice:notebook -->';
+  const section = `${marker}\n\n## Notebook do projeto\n\n[Abra o notebook no Gemini Notebook Enterprise](${notebook.notebookUrl})\n\nO vínculo técnico do projeto está em \`.artifice/notebook.json\`; credenciais ficam apenas em \`~/.artificerc\`.\n\n${endMarker}`;
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '# Artifice\n';
+  fs.writeFileSync(file, existing.includes(marker) ? existing.replace(new RegExp(`${marker}[\\s\\S]*?${endMarker}`), section) : `${existing.trim()}\n\n${section}\n`, 'utf8');
+}
+
+function writeSpec(notebook, cwd) {
+  const file = path.join(cwd, 'SPEC.md');
+  if (fs.existsSync(file)) throw new Error(`SPEC.md já existe em ${cwd}. Mova-o ou renomeie-o antes de executar explore.`);
+  fs.writeFileSync(file, `# SPEC.md - Configuração do Projeto\n\n## Explore\n\n- **Ferramenta:** Gemini Notebook Enterprise\n- **Notebook:** [${notebook.title}](${notebook.notebookUrl})\n- **Recurso:** \`${notebook.name}\`\n\nAgentes devem usar \`artifice source <url>\` para acrescentar fontes ao notebook vinculado.\n`, 'utf8');
+}
+
+export async function runExplore({ force = false } = {}) {
+  const cwd = process.cwd();
+  if (getProjectNotebook(cwd) && !force) throw new Error('Este projeto já possui notebook. Use --force para criar e vincular outro.');
+  if (fs.existsSync(path.join(cwd, 'SPEC.md'))) throw new Error(`SPEC.md já existe em ${cwd}. Mova-o ou renomeie-o antes de executar explore.`);
+  console.log(chalk.bold.blue('\n🔎 Artifice Explore'));
+  const answers = await inquirer.prompt([
+    { type: 'input', name: 'projectNumber', message: 'Número do projeto Google Cloud:', validate: (value) => /^\d+$/.test(value.trim()) || 'Informe o número do projeto (apenas dígitos).' },
+    { type: 'list', name: 'location', message: 'Localização do notebook:', choices: ['global', 'us', 'eu'], default: 'global' },
+    { type: 'list', name: 'endpointRegion', message: 'Multirregião do endpoint da API:', choices: ['global', 'us', 'eu'], default: 'global' },
+    { type: 'input', name: 'title', message: 'Título do notebook:', default: path.basename(cwd) }
+  ]);
+  const notebook = await createNotebook({ ...answers, projectNumber: answers.projectNumber.trim(), title: answers.title.trim() });
+  saveProjectNotebook(notebook, cwd);
+  writeReadmeLink(notebook, cwd);
+  writeSpec(notebook, cwd);
+  console.log(chalk.green(`✓ Notebook criado: ${notebook.notebookUrl}`));
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@v-aranda/artifice",
+  "version": "1.0.2",
+  "description": "CLI para scaffolding e orquestração de agentes de IA",
+  "type": "module",
+  "bin": { "artifice": "./bin/artifice.js" },
+  "scripts": {
+    "test": "vitest run",
+    "build:standalone": "node scripts/build-standalone.mjs",
+    "build:linux": "node scripts/build-standalone.mjs --output release/artifice",
+    "build:windows": "node scripts/build-standalone.mjs --output release/artifice.exe"
+  },
+  "keywords": ["cli", "scaffold", "notebooklm", "agents"],
+  "author": "Artifice Team",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/v-aranda/Artifice.git" },
+  "bugs": { "url": "https://github.com/v-aranda/Artifice/issues" },
+  "homepage": "https://github.com/v-aranda/Artifice#readme",
+  "files": ["bin", "src", "README.md", "LICENSE"],
+  "engines": { "node": ">=20" },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "googleapis": "^129.0.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "postject": "^1.0.0-alpha.6",
+    "vitest": "^1.2.0"
+  }
+}

package/src/auth/google-auth.js

@@ -0,0 +1,80 @@
+import http from 'node:http';
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import { google } from 'googleapis';
+import inquirer from 'inquirer';
+import { getLocalConfig, saveLocalConfig } from '../utils/config.js';
+
+export const GOOGLE_SCOPE = 'https://www.googleapis.com/auth/cloud-platform';
+
+function openBrowser(url) {
+  const command = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  execFile(command, args, () => {});
+}
+
+function waitForAuthorizationCode(server) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error('Tempo esgotado aguardando o login Google.'));
+    }, 180_000);
+    server.once('authorization-code', (code) => {
+      clearTimeout(timeout);
+      resolve(code);
+    });
+  });
+}
+
+async function authorizeWithOAuth() {
+  const answers = await inquirer.prompt([
+    { type: 'input', name: 'clientId', message: 'OAuth Client ID (aplicação Desktop):', validate: (value) => Boolean(value.trim()) || 'Obrigatório.' },
+    { type: 'password', name: 'clientSecret', message: 'OAuth Client Secret:', mask: '*', validate: (value) => Boolean(value.trim()) || 'Obrigatório.' }
+  ]);
+  const server = http.createServer((request, response) => {
+    const url = new URL(request.url, 'http://127.0.0.1');
+    const code = url.searchParams.get('code');
+    response.writeHead(code ? 200 : 400, { 'Content-Type': 'text/html; charset=utf-8' });
+    response.end(code ? '<h1>Autorização concluída.</h1><p>Você pode fechar esta janela.</p>' : '<h1>Falha na autorização.</h1>');
+    if (code) server.emit('authorization-code', code);
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const redirectUri = `http://127.0.0.1:${server.address().port}/oauth2callback`;
+  const client = new google.auth.OAuth2(answers.clientId.trim(), answers.clientSecret.trim(), redirectUri);
+  const url = client.generateAuthUrl({ access_type: 'offline', prompt: 'consent', scope: [GOOGLE_SCOPE] });
+  console.log(`\nAbra este endereço para autenticar:\n${url}\n`);
+  openBrowser(url);
+  const code = await waitForAuthorizationCode(server);
+  server.close();
+  const { tokens } = await client.getToken(code);
+  client.setCredentials(tokens);
+  return { method: 'oauth', clientId: answers.clientId.trim(), clientSecret: answers.clientSecret.trim(), redirectUri, tokens, updatedAt: new Date().toISOString() };
+}
+
+async function configureServiceAccount() {
+  const { filePath } = await inquirer.prompt([{ type: 'input', name: 'filePath', message: 'Caminho absoluto do JSON da Service Account:', validate: (value) => fs.existsSync(value.trim()) || 'Arquivo não encontrado.' }]);
+  return { method: 'service_account', keyFile: filePath.trim(), updatedAt: new Date().toISOString() };
+}
+
+export async function configureGoogleAuth() {
+  const { method } = await inquirer.prompt([{ type: 'list', name: 'method', message: 'Método de autenticação Google:', choices: [
+    { name: 'OAuth 2.0 (recomendado para notebook de um usuário)', value: 'oauth' },
+    { name: 'Service Account (automação no Google Cloud)', value: 'service_account' }
+  ] }]);
+  const credentials = method === 'oauth' ? await authorizeWithOAuth() : await configureServiceAccount();
+  saveLocalConfig({ ...getLocalConfig(), google: credentials });
+  return credentials;
+}
+
+export async function getGoogleAuth(forceConfigure = false) {
+  let credentials = forceConfigure ? null : getLocalConfig().google;
+  if (!credentials) credentials = await configureGoogleAuth();
+  if (credentials.method === 'service_account') return new google.auth.GoogleAuth({ keyFile: credentials.keyFile, scopes: [GOOGLE_SCOPE] });
+  const client = new google.auth.OAuth2(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+  client.setCredentials(credentials.tokens);
+  client.on('tokens', (tokens) => {
+    credentials.tokens = { ...credentials.tokens, ...tokens };
+    saveLocalConfig({ ...getLocalConfig(), google: credentials });
+  });
+  return client;
+}

package/src/notebooklm/client.js

@@ -0,0 +1,32 @@
+import { getGoogleAuth } from '../auth/google-auth.js';
+
+function endpoint(region) {
+  const prefix = region === 'global' ? '' : `${region}-`;
+  return `https://${prefix}discoveryengine.googleapis.com/v1alpha`;
+}
+
+export function notebookUrl({ projectNumber, location, notebookId }) {
+  return `https://notebook.cloud.google.com/${location}/notebook/${notebookId}?project=${projectNumber}`;
+}
+
+export async function createNotebook({ projectNumber, location, endpointRegion, title }) {
+  const auth = await getGoogleAuth();
+  const token = await auth.getAccessToken();
+  const response = await fetch(`${endpoint(endpointRegion)}/projects/${projectNumber}/locations/${location}/notebooks`, {
+    method: 'POST', headers: { Authorization: `Bearer ${token.token || token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ title })
+  });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error?.message || `Google API retornou ${response.status}.`);
+  return { ...body, projectNumber, location, endpointRegion, notebookUrl: notebookUrl({ projectNumber, location, notebookId: body.notebookId }) };
+}
+
+export async function addWebSource(notebook, url, sourceName) {
+  const auth = await getGoogleAuth();
+  const token = await auth.getAccessToken();
+  const response = await fetch(`${endpoint(notebook.endpointRegion)}/${notebook.name}/sources:batchCreate`, {
+    method: 'POST', headers: { Authorization: `Bearer ${token.token || token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ userContents: [{ webContent: { url, sourceName } }] })
+  });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error?.message || `Google API retornou ${response.status}.`);
+  return body;
+}

package/src/utils/config.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const getConfigPath = () => process.env.ARTIFICE_CONFIG_PATH || path.join(os.homedir(), '.artificerc');
+
+export function getLocalConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveLocalConfig(config) {
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: 'utf8', mode: 0o600 });
+  try { fs.chmodSync(configPath, 0o600); } catch { /* Windows does not support POSIX modes. */ }
+}
+
+export function clearLocalConfig() {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+}

package/src/utils/project-config.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const projectConfigPath = (cwd = process.cwd()) => path.join(cwd, '.artifice', 'notebook.json');
+
+export function getProjectNotebook(cwd) {
+  const file = projectConfigPath(cwd);
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+export function saveProjectNotebook(notebook, cwd) {
+  const file = projectConfigPath(cwd);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(notebook, null, 2), 'utf8');
+  return file;
+}