conectese 0.1.14

package/src/readme/README.md

@@ -0,0 +1,119 @@
+# Conectese
+
+Crie squads de agentes de IA que trabalham juntos — direto do seu IDE.
+
+## Como Usar
+
+Abra esta pasta no seu IDE e digite:
+
+```
+/conectese
+```
+
+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:
+
+```
+/conectese crie um squad para escrever posts no LinkedIn sobre IA
+/conectese execute o squad meu-squad
+```
+
+## Criar um Squad
+
+Digite `/conectese` e escolha "Criar squad" no menu, ou seja direto:
+
+```
+/conectese crie um squad para [o que você precisa]
+```
+
+O Arquiteto fará algumas perguntas, projetará o squad e configurará tudo automaticamente.
+
+## Executar um Squad
+
+Digite `/conectese` e escolha "Executar squad" no menu, ou seja direto:
+
+```
+/conectese 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.
+
+**Passo 1 — Gere o dashboard** (no seu IDE):
+
+```
+/conectese dashboard
+```
+
+**Passo 2 — Sirva localmente** (no terminal):
+
+```bash
+npx serve squads/<nome-do-squad>/dashboard
+```
+
+**Passo 3 —** Abra `http://localhost:3000` no seu navegador.
+
+---
+
+# Conectese (English)
+
+Create AI squads that work together — right from your IDE.
+
+## How to Use
+
+Open this folder in your IDE and type:
+
+```
+/conectese
+```
+
+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:
+
+```
+/conectese create a squad for writing LinkedIn posts about AI
+/conectese run my-squad
+```
+
+## Create a Squad
+
+Type `/conectese` and choose "Create squad" from the menu, or be direct:
+
+```
+/conectese 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 `/conectese` and choose "Run squad" from the menu, or be direct:
+
+```
+/conectese 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):
+
+```
+/conectese 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,90 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const MAX_RUNS = 20;
+
+export async function listRuns(squadName, targetDir = process.cwd()) {
+  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 = [];
+
+  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()).map((e) => e.name);
+    } catch {
+      continue;
+    }
+
+    for (const runId of runDirs) {
+      const run = { squad: name, runId, status: 'unknown', steps: null, duration: null };
+
+      try {
+        const raw = await readFile(join(outputDir, runId, '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
+      }
+
+      runs.push(run);
+    }
+  }
+
+  runs.sort((a, b) => b.runId.localeCompare(a.runId));
+  return runs.slice(0, MAX_RUNS);
+}
+
+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) {
+  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}`];
+    parts.push(`[${run.status}]`);
+    if (run.steps) parts.push(`${run.steps} steps`);
+    if (run.duration) parts.push(run.duration);
+    console.log(parts.join('  '));
+  }
+  console.log();
+}

package/src/skills-cli.js

@@ -0,0 +1,157 @@
+import { createInterface } from 'node:readline';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listInstalled, installSkill, removeSkill, getSkillMeta, getLocalizedDescription } from './skills.js';
+import { loadLocale, t, getLocaleCode } from './i18n.js';
+import { loadSavedLocale } from './init.js';
+import { logEvent } from './logger.js';
+
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+export async function skillsCli(subcommand, args, targetDir) {
+  // Require initialized project
+  try {
+    await stat(join(targetDir, '_conectese'));
+  } catch {
+    await loadLocale('English');
+    console.log(`\n  ${t('skillsNotInitialized')}\n`);
+    return { success: false };
+  }
+
+  await loadSavedLocale(targetDir);
+
+  try {
+    if (subcommand === 'list' || !subcommand) {
+      await runList(targetDir);
+    } else if (subcommand === 'install') {
+      const installed = await runInstall(args[0], targetDir);
+      if (installed === false) return { success: false };
+    } else if (subcommand === 'remove') {
+      const removed = await runRemove(args[0], targetDir);
+      if (removed === false) return { success: false };
+    } else if (subcommand === 'update') {
+      await runUpdate(targetDir);
+    } else if (subcommand === 'update-one') {
+      await runUpdateOne(args[0], targetDir);
+    } else {
+      console.log(`\n  ${t('skillsUnknownCommand', { cmd: subcommand })}\n`);
+      return { success: false };
+    }
+  } catch (err) {
+    console.log(`\n  ${t('skillsError', { message: err.message })}\n`);
+    return { success: false };
+  }
+
+  return { success: true };
+}
+
+async function runList(targetDir) {
+  console.log(`\n  Conectese Skills\n`);
+
+  const installed = await listInstalled(targetDir);
+
+  if (installed.length > 0) {
+    console.log(`  ${t('skillsInstalledHeader')}`);
+    for (const id of installed) {
+      const meta = await getSkillMeta(id);
+      if (meta) {
+        const desc = getLocalizedDescription(meta, getLocaleCode());
+        const parts = [meta.name];
+        if (meta.type) parts.push(`(${meta.type})`);
+        parts.push(`- ${desc.split('.')[0]}`);
+        console.log(`    ${parts.join(' ')}`);
+      } else {
+        console.log(`    ${id}`);
+      }
+    }
+  } else {
+    console.log(`  ${t('skillsNoneInstalled')}`);
+  }
+
+  console.log(`\n  Browse available skills at: https://github.com/renatoasse/conectese/tree/main/skills\n`);
+}
+
+async function runInstall(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: conectese install <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (installed.includes(id)) {
+    const answer = await confirm(`\n  ${t('skillsAlreadyInstalled', { id })}`);
+    // Accept 'y' (English) or 's' (Portuguese "sim") as affirmative answers
+    if (answer !== 'y' && answer !== 's') return false;
+    console.log(`  ${t('skillsInstalling', { id })}`);
+    await installSkill(id, targetDir);
+    console.log(`  ${t('skillsReinstalled', { id })}\n`);
+    await logEvent('skill:install', { name: id, reinstall: true }, targetDir);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsInstalling', { id })}`);
+  await installSkill(id, targetDir);
+  console.log(`  ${t('skillsInstalled', { id })}\n`);
+  await logEvent('skill:install', { name: id }, targetDir);
+}
+
+async function runRemove(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: conectese uninstall <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('skillsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsRemoving', { id })}`);
+  await removeSkill(id, targetDir);
+  await logEvent('skill:remove', { name: id }, targetDir);
+  console.log(`  ${t('skillsRemoved', { id })}\n`);
+}
+
+async function runUpdate(targetDir) {
+  const installed = await listInstalled(targetDir);
+  if (installed.length === 0) {
+    console.log(`\n  ${t('skillsUpdateNone')}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsUpdating')}`);
+  for (const id of installed) {
+    console.log(`  ${t('skillsInstalling', { id })}`);
+    await installSkill(id, targetDir);
+    console.log(`  ${t('skillsInstalled', { id })}`);
+  }
+  await logEvent('skill:update', { count: installed.length }, targetDir);
+  console.log(`\n  ${t('skillsUpdateDone', { count: installed.length })}\n`);
+}
+
+async function runUpdateOne(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: conectese update <name>\n');
+    return;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('skillsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('skillsInstalling', { id })}`);
+  await installSkill(id, targetDir);
+  await logEvent('skill:update', { name: id }, targetDir);
+  console.log(`  ${t('skillsInstalled', { id })}\n`);
+}

package/src/skills.js

@@ -0,0 +1,146 @@
+import { cp, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_SKILLS_DIR = join(__dirname, '..', 'skills');
+
+const metaCache = new Map();
+
+export async function listInstalled(targetDir) {
+  try {
+    const skillsDir = join(targetDir, 'skills');
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isDirectory() && e.name !== 'conectese-skill-creator')
+      .map((e) => e.name);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+export async function listAvailable() {
+  try {
+    const entries = await readdir(BUNDLED_SKILLS_DIR, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export async function getSkillMeta(id) {
+  if (metaCache.has(id)) return metaCache.get(id);
+  try {
+    const raw = await readFile(join(BUNDLED_SKILLS_DIR, id, 'SKILL.md'), 'utf-8');
+    const content = raw.replace(/\r\n/g, '\n');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return { name: id, description: '', descriptions: {}, type: '', env: [] };
+
+    const fm = fmMatch[1];
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() || id;
+    const type = fm.match(/^type:\s*(.+)$/m)?.[1]?.trim() || '';
+
+    // description may use YAML folded scalar (>)
+    let description = '';
+    const descBlock = fm.match(/^description:\s*>\s*\n((?:\s{2,}.+\n?)+)/m);
+    if (descBlock) {
+      description = descBlock[1].replace(/\n\s*/g, ' ').trim();
+    } else {
+      const descInline = fm.match(/^description:\s*(.+)$/m);
+      if (descInline) description = descInline[1].trim();
+    }
+
+    // localized descriptions: description_pt-BR, description_es, etc.
+    const descriptions = {};
+    for (const code of ['pt-BR', 'es']) {
+      const key = `description_${code}`;
+      // folded scalar
+      const blockMatch = fm.match(new RegExp(`^${key}:\\s*>\\s*\\n((?:\\s{2,}.+\\n?)+)`, 'm'));
+      if (blockMatch) {
+        descriptions[code] = blockMatch[1].replace(/\n\s*/g, ' ').trim();
+      } else {
+        // inline
+        const inlineMatch = fm.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+        if (inlineMatch) descriptions[code] = inlineMatch[1].trim();
+      }
+    }
+
+    // env is a YAML list: lines starting with "  - "
+    const env = [];
+    const envSection = fm.match(/^env:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (envSection) {
+      for (const line of envSection[1].split('\n')) {
+        const item = line.match(/^\s+-\s+(.+)/);
+        if (item) env.push(item[1].trim());
+      }
+    }
+
+    const result = { name, description, descriptions, type, env };
+    metaCache.set(id, result);
+    return result;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      metaCache.set(id, null);
+      return null;
+    }
+    throw err;
+  }
+}
+
+function validateSkillId(id) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
+    throw new Error(`Invalid skill id: '${id}'`);
+  }
+}
+
+export async function installSkill(id, targetDir) {
+  validateSkillId(id);
+  const srcDir = join(BUNDLED_SKILLS_DIR, id);
+  try {
+    await stat(srcDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error(`Skill '${id}' not found in registry`, { cause: err });
+    throw err;
+  }
+  const destDir = join(targetDir, 'skills', id);
+  const resolvedSrc = resolve(srcDir);
+  const resolvedDest = resolve(destDir);
+  if (resolvedSrc === resolvedDest || resolvedDest.startsWith(resolvedSrc + sep)) {
+    return;
+  }
+  await cp(srcDir, destDir, { recursive: true });
+  metaCache.delete(id);
+}
+
+export async function removeSkill(id, targetDir) {
+  validateSkillId(id);
+  const skillDir = join(targetDir, 'skills', id);
+  await rm(skillDir, { recursive: true, force: true });
+  metaCache.delete(id);
+}
+
+export function clearMetaCache() {
+  metaCache.clear();
+}
+
+export async function getSkillVersion(id, targetDir) {
+  try {
+    const skillPath = join(targetDir, 'skills', id, 'SKILL.md');
+    const content = await readFile(skillPath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+    const versionMatch = fmMatch[1].match(/^version:\s*(.+)$/m);
+    return versionMatch ? versionMatch[1].trim() : null;
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+export function getLocalizedDescription(meta, localeCode) {
+  if (localeCode && localeCode !== 'en' && meta.descriptions?.[localeCode]) {
+    return meta.descriptions[localeCode];
+  }
+  return meta.description;
+}

package/src/update.js

@@ -0,0 +1,169 @@
+import { cp, mkdir, readFile, stat } from 'node:fs/promises';
+import { join, dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadLocale, t } from './i18n.js';
+import { getTemplateEntries, loadSavedLocale, copyCanonicalSources } from './init.js';
+import { listAvailable as listAvailableSkills, listInstalled as listInstalledSkills, installSkill, getSkillMeta } from './skills.js';
+import { logEvent } from './logger.js';
+
+async function loadSavedIdes(targetDir) {
+  try {
+    const prefsPath = join(targetDir, '_conectese', '_memory', 'preferences.md');
+    const content = await readFile(prefsPath, 'utf-8');
+    const match = content.match(/\*\*IDEs:\*\*\s*(.+)/);
+    if (match) {
+      return match[1].trim().split(/,\s*/);
+    }
+  } catch {
+    // No preferences file
+  }
+  return ['claude-code'];
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+const PROTECTED_PATHS = [
+  '_conectese/_memory',
+  'agents',
+  'squads',
+];
+
+function isProtected(relativePath) {
+  const normalized = relativePath.replaceAll('\\', '/');
+  return PROTECTED_PATHS.some(
+    (p) => normalized === p || normalized.startsWith(p + '/')
+  );
+}
+
+async function backupIfExists(destPath) {
+  try {
+    await stat(destPath);
+    const backupPath = destPath + '.bak';
+    await cp(destPath, backupPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function update(targetDir) {
+  console.log('\n  🔄 Conectese — Update\n');
+
+  // 1. Check initialized
+  try {
+    await stat(join(targetDir, '_conectese'));
+  } catch {
+    await loadLocale('English');
+    console.log(`  ${t('updateNotInitialized')}`);
+    return { success: false };
+  }
+
+  // 2. Load user's locale
+  await loadSavedLocale(targetDir);
+
+  // 3. Read versions
+  let currentVersion = null;
+  try {
+    currentVersion = (
+      await readFile(join(targetDir, '_conectese', '.conectese-version'), 'utf-8')
+    ).trim();
+  } catch {
+    // Legacy install — no version file
+  }
+
+  const newVersion = (
+    await readFile(join(TEMPLATES_DIR, '_conectese', '.conectese-version'), 'utf-8')
+  ).trim();
+
+  // 4. Announce
+  if (currentVersion) {
+    console.log(
+      `  ${t('updateStarting', { old: `v${currentVersion}`, new: `v${newVersion}` })}`
+    );
+  } else {
+    console.log(`  ${t('updateStartingUnknown', { new: `v${newVersion}` })}`);
+  }
+
+  // 5. Copy common templates, skipping protected paths and ide-templates/
+  const entries = await getTemplateEntries(TEMPLATES_DIR);
+  let count = 0;
+
+  for (const entry of entries) {
+    const relativePath = relative(TEMPLATES_DIR, entry);
+    if (isProtected(relativePath)) continue;
+    // Skip ide-templates — handled separately below
+    if (relativePath.replaceAll('\\', '/').startsWith('ide-templates/')) continue;
+
+    const destPath = join(targetDir, relativePath);
+    await mkdir(dirname(destPath), { recursive: true });
+    const backed = await backupIfExists(destPath);
+    await cp(entry, destPath);
+    const displayPath = relativePath.replaceAll('\\', '/');
+    if (backed) {
+      console.log(`  ${t('updatedFile', { path: displayPath })} (backup: ${displayPath}.bak)`);
+    } else {
+      console.log(`  ${t('updatedFile', { path: displayPath })}`);
+    }
+    count++;
+  }
+
+  // 6. Copy IDE-specific templates based on saved preferences
+  const ides = await loadSavedIdes(targetDir);
+  for (const ide of ides) {
+    const ideSrcDir = join(TEMPLATES_DIR, 'ide-templates', ide);
+    let ideEntries;
+    try {
+      ideEntries = await getTemplateEntries(ideSrcDir);
+    } catch {
+      continue; // no template dir for this IDE
+    }
+    for (const entry of ideEntries) {
+      const relPath = relative(ideSrcDir, entry);
+      if (isProtected(relPath)) continue;
+
+      const destPath = join(targetDir, relPath);
+      await mkdir(dirname(destPath), { recursive: true });
+      const backed = await backupIfExists(destPath);
+      await cp(entry, destPath);
+      const displayPath = relPath.replaceAll('\\', '/');
+      if (backed) {
+        console.log(`  ${t('updatedFile', { path: displayPath })} (backup: ${displayPath}.bak)`);
+      } else {
+        console.log(`  ${t('updatedFile', { path: displayPath })}`);
+      }
+      count++;
+    }
+  }
+
+  // 6a. Copy canonical sources (core, config, dashboard)
+  count += await copyCanonicalSources(targetDir, {
+    overwrite: true,
+    backupFn: backupIfExists,
+    protectedFn: isProtected,
+  });
+
+  // 6b. Install new non-MCP, non-hybrid bundled skills not already present
+  const availableSkills = await listAvailableSkills();
+  const installedSkills = await listInstalledSkills(targetDir);
+  for (const id of availableSkills) {
+    if (id === 'conectese-skill-creator') continue;
+    if (installedSkills.includes(id)) continue;
+    const meta = await getSkillMeta(id);
+    if (!meta) continue;
+    if (meta.type === 'mcp' || meta.type === 'hybrid') continue;
+    await installSkill(id, targetDir);
+    console.log(`  ${t('createdFile', { path: `skills/${id}/SKILL.md` })}`);
+    count++;
+  }
+
+  // 7. Summary
+  console.log(`\n  ${t('updateFileCount', { count })}`);
+  console.log(`  ${t('updatePreserved')}`);
+  console.log(`  ${t('updateSuccess', { version: `v${newVersion}` })}`);
+  console.log(`\n  ${t('updateLatestHint')}\n`);
+
+  await logEvent('update', { from: currentVersion || 'unknown', to: newVersion }, targetDir);
+
+  return { success: true };
+}

package/templates/_conectese/.conectese-version

@@ -0,0 +1 @@
+0.1.14