@julioventura/opensquad 0.1.17

package/src/locales/pt-BR.json

@@ -0,0 +1,78 @@
+{
+  "welcome": "Bem-vindo! Vamos configurar o Opensquad para o seu projeto.",
+  "askName": "Qual é o seu nome? → ",
+  "atLeastOneIde": "Selecione pelo menos uma IDE.",
+  "chooseIdes": "Quais IDEs/ferramentas você usa? (selecione todas que usa)",
+  "step1Codex": "1. Veja AGENTS.md na raiz do projeto para instruções do Codex",
+  "step1Antigravity": "1. Abra o Antigravity, digite / no chat e selecione opensquad para começar.",
+  "step1Cursor": "1. Abra o Cursor, digite / no chat e selecione opensquad para começar.",
+  "step1Opencode": "1. Abra o OpenCode e digite /opensquad para começar.",
+  "ideNotAvailable": "⚠️  \"{label}\" ainda não está disponível. Escolha outra opção.",
+  "enterNumber": "Por favor, digite um número entre 1 e {max}.",
+  "alreadyInitialized": "⚠️  Opensquad já está inicializado neste diretório.",
+  "alreadyInitializedHint": "Use o Claude Code e digite /opensquad para começar.",
+  "createdFile": "📄 Criado {path}",
+  "success": "✅ Opensquad inicializado com sucesso!",
+  "nextSteps": "Próximos passos:",
+  "step1ClaudeCode": "1. Abra este diretório no Claude Code",
+  "step2ClaudeCode": "2. Digite /opensquad para iniciar o assistente",
+  "step3ClaudeCode": "3. Siga as instruções para configurar o perfil da sua empresa",
+  "comingSoon": "em breve",
+  "updateNotInitialized": "Nenhuma instalação do Opensquad encontrada. Execute 'init' primeiro.",
+  "updateStarting": "Atualizando Opensquad {old} → {new}...",
+  "updateStartingUnknown": "Atualizando Opensquad (versão desconhecida) → {new}...",
+  "updatedFile": "📄 Atualizado {path}",
+  "updateSuccess": "✅ Opensquad {version} instalado com sucesso!",
+  "updatePreserved": "✓ Preservado: _memory/, _investigations/, squads/",
+  "updateFileCount": "✓ Atualizados: {count} arquivos do sistema",
+  "updateLatestHint": "💡 Dica: Use 'npx @julioventura/opensquad@latest update' para sempre obter a versão mais recente.",
+  "skillsNotInitialized": "Instalação Opensquad não encontrada. Execute 'init' primeiro.",
+  "skillsFetching": "Buscando registro de skills...",
+  "skillsInstalledHeader": "Instaladas:",
+  "skillsAvailableHeader": "Disponíveis:",
+  "skillsNoneInstalled": "Nenhuma skill instalada ainda.",
+  "skillsNoneAvailable": "Nenhuma skill disponível no registro.",
+  "skillsInstallHint": "Instale com: npx @julioventura/opensquad install <id>",
+  "skillsInstalling": "Instalando {id}...",
+  "skillsInstalled": "✅ Instalada: {id}",
+  "skillsAlreadyInstalled": "⚠️  {id} já está instalada. Reinstalar? (s/n) ",
+  "skillsReinstalled": "✅ Reinstalada: {id}",
+  "skillsRemoving": "Removendo {id}...",
+  "skillsRemoved": "✅ Removida: {id}",
+  "skillsNotInstalled": "⚠️  {id} não está instalada.",
+  "skillsUpdating": "Atualizando todas as skills instaladas...",
+  "skillsUpdateDone": "✅ {count} skill(s) atualizada(s).",
+  "skillsUpdateNone": "Nenhuma skill instalada para atualizar.",
+  "skillsError": "❌ Erro: {message}",
+  "skillsUnknownCommand": "Comando desconhecido: {cmd}\n  Uso: opensquad skills list|install|remove|update",
+  "chooseSkills": "Quais skills você quer instalar? (opcional)",
+  "skillsEnvWarning": "   Requer: {vars}",
+  "skillsSkipped": "Você pode instalar skills depois com: npx @julioventura/opensquad install <nome>",
+  "skillsInstalledCount": "{count} skill(s) instalada(s).",
+  "agentsNotInitialized": "Instalação Opensquad não encontrada. Execute 'init' primeiro.",
+  "agentsInstalledHeader": "Instalados:",
+  "agentsNoneInstalled": "Nenhum agent instalado ainda.",
+  "agentsInstallHint": "Instale com: npx @julioventura/opensquad agents install <id>",
+  "agentsInstalling": "Instalando {id}...",
+  "agentsInstalled": "✅ Instalado: {id}",
+  "agentsAlreadyInstalled": "⚠️  {id} já está instalado. Reinstalar? (s/n) ",
+  "agentsReinstalled": "✅ Reinstalado: {id}",
+  "agentsRemoving": "Removendo {id}...",
+  "agentsRemoved": "✅ Removido: {id}",
+  "agentsNotInstalled": "⚠️  {id} não está instalado.",
+  "agentsUpdating": "Atualizando todos os agents instalados...",
+  "agentsUpdateDone": "✅ {count} agent(s) atualizado(s).",
+  "agentsUpdateNone": "Nenhum agent instalado para atualizar.",
+  "agentsError": "❌ Erro: {message}",
+  "agentsUnknownCommand": "Comando desconhecido: {cmd}\n  Uso: opensquad agents list|install|remove|update",
+  "step1VsCodeCopilot": "1. Abra este diretório no VS Code",
+  "step2VsCodeCopilot": "2. Abra o Copilot Chat (Ctrl+Alt+I)",
+  "step3VsCodeCopilot": "3. Digite /opensquad para começar",
+  "step1QwenCode": "1. Abra este diretório no Qwen Code",
+  "step2QwenCode": "2. Digite /opensquad para começar",
+  "step1GeminiCli": "1. Abra este diretório no Gemini CLI",
+  "step2GeminiCli": "2. Digite /opensquad para começar",
+  "step1Trae": "1. Abra este projeto no Trae",
+  "step2Trae": "2. Digite /opensquad no chat para começar",
+  "tokenCostWarning": "Executar squads consome tokens de IA (pagos). Monitore seu consumo na sua IDE ou no dashboard do provedor de IA."
+}

package/src/logger.js

@@ -0,0 +1,38 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export async function logEvent(action, details = {}, targetDir = process.cwd()) {
+  try {
+    const logDir = join(targetDir, '_opensquad', 'logs');
+    await mkdir(logDir, { recursive: true });
+    const entry = JSON.stringify({
+      timestamp: new Date().toISOString(),
+      action,
+      details,
+    });
+    await appendFile(join(logDir, 'cli.log'), entry + '\n', 'utf-8');
+  } catch {
+    // Silent — logging must never break the operation
+  }
+}
+
+export async function readCliLogs({ action, limit } = {}, targetDir = process.cwd()) {
+  try {
+    const raw = await readFile(join(targetDir, '_opensquad', 'logs', 'cli.log'), 'utf-8');
+    const lines = raw.trim().split('\n');
+    let entries = [];
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        // Skip malformed lines
+      }
+    }
+    entries.reverse(); // newest first
+    if (action) entries = entries.filter((e) => e.action === action);
+    if (limit) entries = entries.slice(0, limit);
+    return entries;
+  } catch {
+    return [];
+  }
+}

package/src/prompt.js

@@ -0,0 +1,46 @@
+import { t } from './i18n.js';
+
+export function createPrompt() {
+  return {
+    async ask(question) {
+      const { default: input } = await import('@inquirer/input');
+      return input({ message: question });
+    },
+    async choose(question, options) {
+      const { default: select } = await import('@inquirer/select');
+
+      const choices = options.map(opt => ({
+        name: opt.label,
+        value: opt,
+      }));
+
+      return select({
+        message: `  ${question}`,
+        choices,
+        loop: false,
+      });
+    },
+    async multiChoose(question, options, { validate } = {}) {
+      const { default: checkbox, Separator } = await import('@inquirer/checkbox');
+
+      const choices = options.map(opt => {
+        if (opt.separator) return new Separator(opt.label);
+        return {
+          name: opt.label,
+          value: opt.value,
+          checked: opt.checked ?? false,
+          disabled: opt.disabled ? t('comingSoon') : false,
+        };
+      });
+
+      return checkbox({
+        message: `  ${question}`,
+        choices,
+        loop: false,
+        validate: validate ?? ((selected) =>
+          selected.length > 0 || t('atLeastOneIde')),
+      });
+    },
+    close() {},
+  };
+}

package/src/readme/README.md

@@ -0,0 +1,146 @@
+# Opensquad
+
+Crie squads de agentes de IA que trabalham juntos — direto do seu IDE.
+
+## Como Usar
+
+Abra esta pasta no seu IDE e digite:
+
+```
+/opensquad
+```
+
+Isso abre o menu principal. De lá você pode criar squads, executá-los e mais.
+
+Você também pode ser direto — descreva o que quer em linguagem natural:
+
+```
+/opensquad crie um squad para escrever posts no LinkedIn sobre IA
+/opensquad execute o squad meu-squad
+```
+
+## Criar um Squad
+
+Digite `/opensquad` e escolha "Criar squad" no menu, ou seja direto:
+
+```
+/opensquad crie um squad para [o que você precisa]
+```
+
+O Arquiteto fará algumas perguntas, projetará o squad e configurará tudo automaticamente.
+
+## Executar um Squad
+
+Digite `/opensquad` e escolha "Executar squad" no menu, ou seja direto:
+
+```
+/opensquad execute o squad <nome-do-squad>
+```
+
+O squad executa automaticamente, pausando apenas nos checkpoints de decisão.
+
+## Escritório Virtual
+
+O Escritório Virtual é uma interface visual 2D que mostra seus agentes trabalhando em tempo real.
+
+Ele nao e o mesmo artefato que o relatorio operacional em HTML gerado ao final de cada run.
+
+- `opensquad-dashboard-design`: skill de design e evolucao visual do app/dashboard 2D
+- `DASHBOARD 2`: relatorio operacional da run, gerado como `run-dashboard.html` dentro da pasta de output da execucao
+
+**Passo 1 — Rode a squad** (no seu IDE):
+
+```text
+/opensquad
+```
+
+Ou execute diretamente:
+
+```text
+/opensquad run <nome-do-squad>
+```
+
+Ao final da pipeline, o runner gera automaticamente o `DASHBOARD 2` com estes arquivos dentro da run:
+
+- `squads/<nome-do-squad>/output/<run-id>/run-dashboard.html`
+- `squads/<nome-do-squad>/output/<run-id>/run-dashboard.data.json`
+
+Em squads legadas que ainda usam a raiz de `output/`, o HTML pode ficar diretamente em `squads/<nome-do-squad>/output/run-dashboard.html`.
+
+**Passo 2 — Abra localmente**:
+
+- direto no navegador pelo arquivo `run-dashboard.html`; ou
+- sirva a raiz do projeto localmente para navegar por URL HTTP
+
+Exemplo no terminal, a partir de `C:\contexto\OPENSQUAD`:
+
+```bash
+npx serve .
+```
+
+**Passo 3 —** Abra a URL local correspondente ao HTML da run, por exemplo:
+
+```text
+http://localhost:3000/squads/<nome-do-squad>/output/<run-id>/run-dashboard.html
+```
+
+---
+
+# Opensquad (English)
+
+Create AI squads that work together — right from your IDE.
+
+## How to Use
+
+Open this folder in your IDE and type:
+
+```
+/opensquad
+```
+
+This opens the main menu. From there you can create squads, run them, and more.
+
+You can also be direct — describe what you want in plain language:
+
+```
+/opensquad create a squad for writing LinkedIn posts about AI
+/opensquad run my-squad
+```
+
+## Create a Squad
+
+Type `/opensquad` and choose "Create squad" from the menu, or be direct:
+
+```
+/opensquad create a squad for [what you need]
+```
+
+The Architect will ask a few questions, design the squad, and set everything up automatically.
+
+## Run a Squad
+
+Type `/opensquad` and choose "Run squad" from the menu, or be direct:
+
+```
+/opensquad run the <squad-name> squad
+```
+
+The squad runs automatically, pausing only at decision checkpoints.
+
+## Virtual Office
+
+The Virtual Office is a 2D visual interface that shows your agents working in real time.
+
+**Step 1 — Generate the dashboard** (in your IDE):
+
+```
+/opensquad dashboard
+```
+
+**Step 2 — Serve it locally** (in terminal):
+
+```bash
+npx serve squads/<squad-name>/dashboard
+```
+
+**Step 3 —** Open `http://localhost:3000` in your browser.

package/src/runs.js

@@ -0,0 +1,318 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const MAX_RUNS = 20;
+const ARCHIVE_DIR_NAME = 'archive';
+const RUN_METADATA_PATHS = {
+  editorialPlan: ['editorial-plan.md', 'v1/editorial-plan.md'],
+  researchBrief: ['research-brief.md', 'v1/research-brief.md'],
+  publishResult: ['publish-result.md', 'v1/publish-result.md'],
+};
+
+export async function listRuns(squadName, targetDir = process.cwd(), options = {}) {
+  const includeArchived = options.includeArchived || options.archivedOnly;
+  const archivedOnly = options.archivedOnly || false;
+  const includeMetrics = options.includeMetrics || false;
+  const squadsDir = join(targetDir, 'squads');
+  let squadNames;
+
+  try {
+    if (squadName) {
+      squadNames = [squadName];
+    } else {
+      const entries = await readdir(squadsDir, { withFileTypes: true });
+      squadNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+  } catch {
+    return [];
+  }
+
+  const runs = [];
+  const envVars = includeMetrics ? await loadEnvVars(targetDir) : {};
+
+  for (const name of squadNames) {
+    const outputDir = join(squadsDir, name, 'output');
+    let runDirs;
+    try {
+      const entries = await readdir(outputDir, { withFileTypes: true });
+      runDirs = entries
+        .filter((e) => e.isDirectory() && e.name !== ARCHIVE_DIR_NAME)
+        .map((e) => ({ runId: e.name, runPath: join(outputDir, e.name), archived: false }));
+
+      if (includeArchived) {
+        const archiveDir = entries.find((e) => e.isDirectory() && e.name === ARCHIVE_DIR_NAME);
+        if (archiveDir) {
+          const archivedEntries = await readdir(join(outputDir, ARCHIVE_DIR_NAME), { withFileTypes: true });
+          const archivedRuns = archivedEntries
+            .filter((e) => e.isDirectory())
+            .map((e) => ({
+              runId: e.name,
+              runPath: join(outputDir, ARCHIVE_DIR_NAME, e.name),
+              archived: true,
+            }));
+          runDirs.push(...archivedRuns);
+        }
+      }
+    } catch {
+      continue;
+    }
+
+    if (archivedOnly) {
+      runDirs = runDirs.filter((run) => run.archived);
+    }
+
+    for (const { runId, runPath, archived } of runDirs) {
+      const run = {
+        squad: name,
+        runId,
+        archived,
+        status: 'unknown',
+        steps: null,
+        duration: null,
+        theme: null,
+        publishedAt: null,
+        instagramPostId: null,
+        instagramUrl: null,
+        facebookPostId: null,
+        facebookUrl: null,
+        youtubeVideoId: null,
+        youtubeUrl: null,
+        youtubeThumbnail: null,
+        likes: null,
+        views: null,
+        viewsLabel: null,
+      };
+
+      try {
+        const raw = await readFile(join(runPath, 'state.json'), 'utf-8');
+        const state = JSON.parse(raw);
+        run.status = state.status || 'unknown';
+        if (state.step) run.steps = `${state.step.current}/${state.step.total}`;
+        if (state.startedAt && (state.completedAt || state.failedAt)) {
+          const start = new Date(state.startedAt).getTime();
+          const end = new Date(state.completedAt || state.failedAt).getTime();
+          run.duration = formatDuration(end - start);
+        }
+      } catch {
+        // No state.json or malformed — keep defaults
+      }
+
+      await hydrateRunMetadata(run, runPath);
+
+      if (includeMetrics) {
+        await hydrateRunMetrics(run, envVars);
+      }
+
+      runs.push(run);
+    }
+  }
+
+  runs.sort((a, b) => b.runId.localeCompare(a.runId));
+  return runs.slice(0, MAX_RUNS);
+}
+
+async function hydrateRunMetadata(run, runPath) {
+  const editorialPlan = await firstExistingFile(runPath, RUN_METADATA_PATHS.editorialPlan);
+  const researchBrief = await firstExistingFile(runPath, RUN_METADATA_PATHS.researchBrief);
+  const publishResult = await firstExistingFile(runPath, RUN_METADATA_PATHS.publishResult);
+
+  const themeSource = editorialPlan || researchBrief;
+  if (themeSource) {
+    run.theme = extractTheme(themeSource);
+  }
+
+  if (publishResult) {
+    run.publishedAt = extractLabeledValue(publishResult, 'Publicado em');
+    run.instagramPostId = extractLabeledValue(publishResult, 'Instagram Post ID');
+    run.instagramUrl = extractLabeledValue(publishResult, 'Instagram URL');
+    run.facebookPostId = extractLabeledValue(publishResult, 'Facebook Post ID');
+    run.facebookUrl = extractLabeledValue(publishResult, 'Facebook URL');
+    run.youtubeVideoId = extractLabeledValue(publishResult, 'YouTube Video ID');
+    run.youtubeUrl = extractLabeledValue(publishResult, 'YouTube URL');
+    run.youtubeThumbnail = extractLabeledValue(publishResult, 'YouTube Thumbnail');
+    const status = extractLabeledValue(publishResult, 'Status');
+    if (status) run.status = status.toLowerCase();
+  }
+}
+
+async function hydrateRunMetrics(run, envVars) {
+  const accessToken = envVars.INSTAGRAM_ACCESS_TOKEN;
+  if (!accessToken || !run.instagramPostId) return;
+
+  const media = await fetchJson(
+    `https://graph.facebook.com/v22.0/${run.instagramPostId}?fields=like_count&access_token=${encodeURIComponent(accessToken)}`,
+  );
+
+  if (media?.like_count != null) {
+    run.likes = media.like_count;
+  }
+
+  const metricsToTry = [
+    { metric: 'views', label: 'views' },
+    { metric: 'video_views', label: 'views' },
+    { metric: 'plays', label: 'views' },
+    { metric: 'impressions', label: 'impressions' },
+  ];
+
+  for (const metric of metricsToTry) {
+    const insight = await fetchJson(
+      `https://graph.facebook.com/v22.0/${run.instagramPostId}/insights?metric=${metric.metric}&access_token=${encodeURIComponent(accessToken)}`,
+    );
+
+    const value = insight?.data?.[0]?.values?.[0]?.value;
+    if (value != null) {
+      run.views = value;
+      run.viewsLabel = metric.label;
+      break;
+    }
+  }
+}
+
+async function fetchJson(url) {
+  try {
+    const response = await fetch(url);
+    const data = await response.json();
+    if (!response.ok || data?.error) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+async function firstExistingFile(runPath, relativePaths) {
+  for (const relativePath of relativePaths) {
+    try {
+      return await readFile(join(runPath, relativePath), 'utf-8');
+    } catch {
+      // Try next path
+    }
+  }
+
+  return null;
+}
+
+function extractTheme(content) {
+  const directPatterns = [
+    /\*\*Tema Central:\*\*\s*(.+)/i,
+    /\*\*Tema central da semana:\*\*\s*(.+)/i,
+  ];
+
+  for (const pattern of directPatterns) {
+    const match = content.match(pattern);
+    if (match) return sanitizeValue(match[1]);
+  }
+
+  const lines = content.split(/\r?\n/);
+  const headingIndex = lines.findIndex((line) => /^##\s+Tema Central da Semana/i.test(line.trim()));
+  if (headingIndex !== -1) {
+    for (let index = headingIndex + 1; index < lines.length; index += 1) {
+      const candidate = sanitizeValue(lines[index]);
+      if (candidate) return candidate;
+    }
+  }
+
+  return null;
+}
+
+function extractLabeledValue(content, label) {
+  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = content.match(new RegExp(`\\*\\*${escapedLabel}:\\*\\*\\s*(.+)`, 'i'));
+  return match ? sanitizeValue(match[1]) : null;
+}
+
+function sanitizeValue(value) {
+  if (!value) return null;
+  return value
+    .replace(/^\*\*|\*\*$/g, '')
+    .replace(/^__|__$/g, '')
+    .replace(/^`|`$/g, '')
+    .replace(/^<|>$/g, '')
+    .trim() || null;
+}
+
+async function loadEnvVars(targetDir) {
+  const envVars = { ...process.env };
+
+  try {
+    const raw = await readFile(join(targetDir, '.env'), 'utf-8');
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const separatorIndex = trimmed.indexOf('=');
+      if (separatorIndex === -1) continue;
+      const key = trimmed.slice(0, separatorIndex).trim();
+      const value = trimmed.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+      if (key && !(key in envVars)) {
+        envVars[key] = value;
+      }
+    }
+  } catch {
+    // Optional .env
+  }
+
+  return envVars;
+}
+
+export function formatDuration(ms) {
+  if (ms <= 0) return '0s';
+  const seconds = Math.floor(ms / 1000);
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${secs}s`;
+  return `${secs}s`;
+}
+
+export function printRuns(runs) {
+  const options = arguments[1] || {};
+  if (runs.length === 0) {
+    console.log('\n  No runs found.\n');
+    return;
+  }
+
+  let currentSquad = null;
+  for (const run of runs) {
+    if (run.squad !== currentSquad) {
+      currentSquad = run.squad;
+      console.log(`\n  ${currentSquad}`);
+      console.log('  ' + '─'.repeat(50));
+    }
+    const parts = [`    ${run.runId}`];
+    if (run.archived) parts.push('[archived]');
+    parts.push(`[${run.status}]`);
+    if (run.steps) parts.push(`${run.steps} steps`);
+    if (run.duration) parts.push(run.duration);
+    console.log(parts.join('  '));
+
+    if (options.showDetails) {
+      const detailParts = [];
+      if (run.theme) detailParts.push(`tema: ${truncate(run.theme, 90)}`);
+      if (run.publishedAt) detailParts.push(`publicado: ${run.publishedAt}`);
+      if (detailParts.length > 0) {
+        console.log(`      ${detailParts.join('  |  ')}`);
+      }
+    }
+
+    if (options.showMetrics) {
+      const metricParts = [];
+      if (run.instagramUrl) metricParts.push(run.instagramUrl);
+      else if (run.youtubeUrl) metricParts.push(run.youtubeUrl);
+
+      const likes = run.likes != null ? run.likes : 'n/a';
+      const views = run.views != null ? run.views : 'n/a';
+      const viewsLabel = run.viewsLabel || 'views';
+      metricParts.push(`likes: ${likes}`);
+      metricParts.push(`${viewsLabel}: ${views}`);
+
+      console.log(`      ${metricParts.join('  |  ')}`);
+    }
+  }
+  console.log();
+}
+
+function truncate(value, maxLength) {
+  if (!value || value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 1)}...`;
+}