@jaimevalasek/aioson 1.5.1 → 1.6.0

package/src/commands/setup.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const path = require('node:path');
+const readline = require('node:readline/promises');
+const { installTemplate, readInstallProfile } = require('../installer');
+const { detectFramework } = require('../detector');
+const { detectSystemLanguage } = require('./setup-context');
+const { runSetupContext } = require('./setup-context');
+const { resolvePromptTool } = require('../prompt-tool');
+const { normalizeBoolean } = require('../context-writer');
+const { runInstallWizard } = require('../install-wizard');
+
+async function ask(rl, question, fallback = '') {
+  const suffix = fallback ? ` (${fallback})` : '';
+  const value = await rl.question(`${question}${suffix}: `);
+  const cleaned = String(value || '').trim();
+  if (!cleaned) return fallback;
+  return cleaned;
+}
+
+async function runSetup({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const dryRun = Boolean(options['dry-run']);
+  const force = Boolean(options.force);
+  const defaultsMode = Boolean(options.defaults);
+  const promptTool = resolvePromptTool(options.tool);
+
+  // Step 1 — detect install profile (wizard if first time in TTY)
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+  let installProfile = null;
+
+  if (!dryRun && isTTY) {
+    const existingProfile = await readInstallProfile(targetDir);
+    if (!existingProfile) {
+      installProfile = await runInstallWizard({});
+    } else {
+      installProfile = existingProfile;
+    }
+  }
+
+  // Step 2 — install template
+  logger.log(t('setup.installing'));
+  const installResult = await installTemplate(targetDir, {
+    overwrite: force,
+    dryRun,
+    mode: 'install',
+    installProfile
+  });
+  logger.log(t('setup.installed', { count: installResult.copied.length }));
+
+  // Step 3 — detect framework and system language
+  const detection = await detectFramework(targetDir);
+  const detectedFramework = detection.framework;
+  const detectedInstalled = detection.installed;
+  const systemLang = detectSystemLanguage();
+
+  // Build setup:context options by merging detected state with explicit flags
+  const contextOptions = { defaults: true };
+
+  // Propagate any explicit overrides the user passed to `setup`
+  const passthroughFlags = [
+    'project-name', 'project-type', 'framework', 'framework-installed',
+    'classification', 'lang', 'language', 'profile', 'backend', 'frontend',
+    'database', 'auth', 'uiux', 'design-skill', 'test-runner',
+    'web3-enabled', 'web3-networks', 'contract-framework',
+    'wallet-provider', 'indexer', 'rpc-provider',
+    'queues', 'storage', 'websockets', 'payments', 'email', 'cache', 'search'
+  ];
+  for (const flag of passthroughFlags) {
+    if (Object.prototype.hasOwnProperty.call(options, flag)) {
+      contextOptions[flag] = options[flag];
+    }
+  }
+
+  // Apply language: explicit flag > system detection
+  if (!contextOptions.lang && !contextOptions.language) {
+    contextOptions.lang = systemLang;
+  }
+
+  // For greenfield projects (nothing detected), ask minimal interactive questions
+  // unless --defaults is set or the user already passed --framework
+  const isGreenfield = !detectedFramework;
+  const frameworkProvided = Object.prototype.hasOwnProperty.call(options, 'framework');
+
+  if (!defaultsMode && isGreenfield && !frameworkProvided) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    try {
+      logger.log(t('setup.no_framework_detected'));
+
+      const projectName = await ask(
+        rl,
+        t('setup.q_project_name'),
+        path.basename(targetDir) || 'my-project'
+      );
+      if (projectName !== path.basename(targetDir)) {
+        contextOptions['project-name'] = projectName;
+      }
+
+      const framework = await ask(rl, t('setup.q_framework'), '');
+      if (framework) {
+        contextOptions.framework = framework;
+        contextOptions['framework-installed'] = 'false';
+      }
+
+      const detectedLang = contextOptions.lang || systemLang;
+      const lang = await ask(rl, t('setup.q_lang'), detectedLang);
+      contextOptions.lang = lang;
+    } finally {
+      rl.close();
+    }
+  } else if (!defaultsMode && detectedFramework) {
+    // Existing project with detected framework — confirm before proceeding
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    try {
+      logger.log(
+        t('setup.framework_detected', {
+          framework: detectedFramework,
+          installed: String(detectedInstalled)
+        })
+      );
+
+      const confirmed = normalizeBoolean(
+        await ask(rl, t('setup.q_confirm_framework'), 'true'),
+        true
+      );
+
+      if (!confirmed) {
+        const override = await ask(rl, t('setup.q_override_framework'), detectedFramework);
+        contextOptions.framework = override;
+        contextOptions['framework-installed'] = await ask(
+          rl,
+          t('setup.q_framework_installed'),
+          'false'
+        );
+      }
+
+      const detectedLang = contextOptions.lang || systemLang;
+      const lang = await ask(rl, t('setup.q_lang'), detectedLang);
+      contextOptions.lang = lang;
+    } finally {
+      rl.close();
+    }
+  }
+
+  // Step 4 — run setup:context with fully resolved options
+  logger.log(t('setup.writing_context'));
+  const contextResult = await runSetupContext({
+    args: [targetDir],
+    options: contextOptions,
+    logger,
+    t
+  });
+
+  if (!dryRun) {
+    logger.log('');
+    logger.log(t('setup.done'));
+    logger.log(t('setup.step_agents'));
+    logger.log(t('setup.step_agent_prompt', { tool: promptTool }));
+  }
+
+  return {
+    ok: true,
+    targetDir,
+    installResult,
+    contextResult,
+    detection
+  };
+}
+
+module.exports = { runSetup };

package/src/commands/skill.js

@@ -16,6 +16,47 @@ function resolveTargetDir(args) {
   return path.resolve(process.cwd(), args[0] || '.');
 }
 
+async function copyRecursive(src, dest) {
+  const stat = await fs.stat(src);
+  if (stat.isDirectory()) {
+    await ensureDir(dest);
+    const entries = await fs.readdir(src);
+    for (const entry of entries) {
+      await copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+
+  await ensureDir(path.dirname(dest));
+  await fs.copyFile(src, dest);
+}
+
+async function replaceDirectory(srcDir, destDir) {
+  await fs.rm(destDir, { recursive: true, force: true });
+  await copyRecursive(srcDir, destDir);
+}
+
+async function readJsonIfExists(filePath) {
+  if (!(await exists(filePath))) return null;
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function writeSkillMeta(destDir, patch) {
+  const metaPath = path.join(destDir, '.skill-meta.json');
+  const existing = await readJsonIfExists(metaPath) || {};
+  const merged = {
+    ...existing,
+    ...patch
+  };
+
+  await fs.writeFile(metaPath, JSON.stringify(merged, null, 2), 'utf8');
+  return merged;
+}
+
 /**
  * Parse YAML frontmatter from a SKILL.md file.
  */
@@ -44,17 +85,7 @@ async function distributeToTool(targetDir, slug, skillDir) {
   for (const toolPath of TOOL_TARGETS) {
     const toolSkillDir = path.join(targetDir, toolPath, slug);
     try {
-      await ensureDir(toolSkillDir);
-      // Copy all files from the installed skill dir
-      const entries = await fs.readdir(skillDir);
-      for (const entry of entries) {
-        const src = path.join(skillDir, entry);
-        const dest = path.join(toolSkillDir, entry);
-        const stat = await fs.stat(src);
-        if (stat.isFile()) {
-          await fs.copyFile(src, dest);
-        }
-      }
+      await replaceDirectory(skillDir, toolSkillDir);
       results.push({ tool: toolPath, ok: true });
     } catch (err) {
       results.push({ tool: toolPath, ok: false, error: err.message });
@@ -187,12 +218,13 @@ async function installFromNpm(targetDir, slug, options, logger) {
 
       // Copy to .aioson/installed-skills/{slug}/
       const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
-      await ensureDir(destDir);
-
-      const entries = await fs.readdir(sourceDir);
-      for (const entry of entries) {
-        await fs.copyFile(path.join(sourceDir, entry), path.join(destDir, entry));
-      }
+      await replaceDirectory(sourceDir, destDir);
+      await writeSkillMeta(destDir, {
+        source: 'npm',
+        sourcePackage: '@tech-leads-club/agent-skills',
+        sourcePath: path.relative(targetDir, sourceDir),
+        installedAt: new Date().toISOString()
+      });
 
       resolve({ ok: true, sourceDir, destDir });
     });
@@ -248,15 +280,16 @@ async function installFromCloud(targetDir, slug, options, logger) {
   ].join('\n');
 
   const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
+  await fs.rm(destDir, { recursive: true, force: true });
   await ensureDir(destDir);
   await fs.writeFile(path.join(destDir, 'SKILL.md'), fm, 'utf8');
 
   // Write meta
-  await fs.writeFile(path.join(destDir, '.skill-meta.json'), JSON.stringify({
+  await writeSkillMeta(destDir, {
     source: 'cloud',
     cloudSlug: snapshot.skill.slug,
     installedAt: new Date().toISOString()
-  }, null, 2), 'utf8');
+  });
 
   return { ok: true, destDir };
 }
@@ -271,30 +304,32 @@ async function installFromLocal(targetDir, slug, filePath, logger) {
   }
 
   const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
-  await ensureDir(destDir);
-
   const stat = await fs.stat(absPath);
+  const samePath = path.resolve(absPath) === path.resolve(destDir);
+
+  if (!samePath) {
+    await fs.rm(destDir, { recursive: true, force: true });
+    await ensureDir(destDir);
+  } else if (!stat.isDirectory()) {
+    return { ok: false, error: 'Local self-install only supports skill directories' };
+  }
+
   if (stat.isDirectory()) {
-    // Copy entire directory
-    const entries = await fs.readdir(absPath);
-    for (const entry of entries) {
-      const src = path.join(absPath, entry);
-      const srcStat = await fs.stat(src);
-      if (srcStat.isFile()) {
-        await fs.copyFile(src, path.join(destDir, entry));
-      }
+    if (!samePath) {
+      await replaceDirectory(absPath, destDir);
     }
   } else {
     // Single file — copy as SKILL.md
+    await ensureDir(destDir);
     await fs.copyFile(absPath, path.join(destDir, 'SKILL.md'));
   }
 
   // Write meta
-  await fs.writeFile(path.join(destDir, '.skill-meta.json'), JSON.stringify({
+  await writeSkillMeta(destDir, {
     source: 'local',
     sourcePath: filePath,
     installedAt: new Date().toISOString()
-  }, null, 2), 'utf8');
+  });
 
   return { ok: true, destDir };
 }
@@ -429,17 +464,27 @@ async function runSkillList({ args, options = {}, logger, t }) {
       const fm = parseSkillFrontmatter(raw);
 
       let source = 'unknown';
+      let meta = null;
       try {
         const metaRaw = await fs.readFile(path.join(skillsDir, slug, '.skill-meta.json'), 'utf8');
-        const meta = JSON.parse(metaRaw);
+        meta = JSON.parse(metaRaw);
         source = meta.source || 'unknown';
       } catch { /* no meta */ }
 
+      const author = meta?.author?.name || meta?.author_name || null;
+      const model =
+        meta?.generator?.model ||
+        meta?.generation?.model ||
+        meta?.generated_by_model ||
+        null;
+
       installed.push({
         slug,
         name: fm.name || slug,
         description: fm.description || '',
         source,
+        author,
+        model,
         path: path.relative(targetDir, path.join(skillsDir, slug))
       });
     }
@@ -472,6 +517,8 @@ async function runSkillList({ args, options = {}, logger, t }) {
       if (s.description) {
         logger.log(`    ${s.description.slice(0, 100)}`);
       }
+      if (s.author) logger.log(`    author: ${s.author}`);
+      if (s.model) logger.log(`    model: ${s.model}`);
       logger.log(`    ${s.path}/SKILL.md`);
       logger.log('');
     }

package/src/commands/tool-registry-cmd.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  registerDynamicTool,
+  unregisterDynamicTool,
+  getDynamicTool,
+  listDynamicTools
+} = require('../runtime-store');
+const { executeTool } = require('../tool-executor');
+
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]*$/;
+
+async function runToolRegistry({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'list';
+
+  if (sub === 'register') return handleRegister(projectDir, options, logger);
+  if (sub === 'list') return handleList(projectDir, options, logger);
+  if (sub === 'call') return handleCall(projectDir, options, logger);
+  if (sub === 'unregister') return handleUnregister(projectDir, options, logger);
+  if (sub === 'show') return handleShow(projectDir, options, logger);
+
+  logger.error(`Subcomando desconhecido: ${sub}. Disponíveis: register, list, call, unregister, show`);
+  return { ok: false, error: 'unknown_sub' };
+}
+
+async function handleRegister(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  const description = String(options.description || options.desc || '').trim();
+  const handlerType = String(options.type || 'shell').trim();
+  const handlerCode = options.cmd ? String(options.cmd) : null;
+  const handlerPath = options.path ? String(options.path) : null;
+  const squadSlug = options.squad ? String(options.squad) : null;
+  const registeredBy = options.by ? String(options.by) : null;
+
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+  if (!TOOL_NAME_RE.test(name) || name.length > 64) {
+    logger.error(`Nome inválido: "${name}". Use apenas letras minúsculas, números e _ (máx 64 chars, começando com letra)`);
+    return { ok: false, error: 'invalid_name' };
+  }
+  if (!description) {
+    logger.error('--description é obrigatório');
+    return { ok: false, error: 'description_required' };
+  }
+  if (!['shell', 'script'].includes(handlerType)) {
+    logger.error('--type deve ser "shell" ou "script"');
+    return { ok: false, error: 'invalid_type' };
+  }
+  if (handlerType === 'shell' && !handlerCode) {
+    logger.error('--cmd é obrigatório para tools do tipo shell');
+    return { ok: false, error: 'cmd_required' };
+  }
+  if (handlerType === 'script' && !handlerPath) {
+    logger.error('--path é obrigatório para tools do tipo script');
+    return { ok: false, error: 'path_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir);
+  if (!handle) {
+    logger.error('Runtime store não encontrado. Execute aioson runtime:init primeiro.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    registerDynamicTool(db, {
+      name,
+      description,
+      handlerType,
+      handlerCode,
+      handlerPath,
+      squadSlug,
+      registeredBy
+    });
+    logger.log(`Tool registrada: ${name} (${handlerType})`);
+    return { ok: true, name, handlerType };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleList(projectDir, options, logger) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.log('Nenhum runtime store encontrado.');
+    return { ok: true, tools: [] };
+  }
+  const { db } = handle;
+
+  try {
+    const tools = listDynamicTools(db, options.squad || null);
+    if (tools.length === 0) {
+      logger.log('Nenhuma tool registrada neste projeto.');
+      return { ok: true, tools: [] };
+    }
+
+    logger.log(`Tools registradas (${tools.length}):`);
+    logger.log('');
+    for (const tool of tools) {
+      const scope = tool.squad_slug ? ` [squad:${tool.squad_slug}]` : '';
+      logger.log(`  ${tool.name}${scope}`);
+      logger.log(`    ${tool.description}`);
+      logger.log(`    tipo: ${tool.handler_type} | registrada: ${tool.registered_at.slice(0, 10)}`);
+      logger.log('');
+    }
+    return { ok: true, tools };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleCall(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  let input = {};
+  if (options.input) {
+    try {
+      input = JSON.parse(String(options.input));
+    } catch {
+      logger.error('--input deve ser JSON válido');
+      return { ok: false, error: 'invalid_input' };
+    }
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  let tool;
+  try {
+    tool = getDynamicTool(db, name);
+  } finally {
+    db.close();
+  }
+
+  if (!tool) {
+    logger.error(`Tool não encontrada: ${name}`);
+    return { ok: false, error: 'tool_not_found' };
+  }
+
+  const timeoutMs = options.timeout ? Number(options.timeout) * 1000 : undefined;
+  const result = executeTool(tool, input, { projectDir, timeoutMs });
+
+  if (result.stdout) logger.log(result.stdout);
+  if (result.stderr) logger.error(result.stderr);
+
+  if (!result.ok) {
+    logger.error(`Tool falhou (exit ${result.exitCode})${result.error ? `: ${result.error}` : ''}`);
+    return { ok: false, exitCode: result.exitCode, error: result.error };
+  }
+
+  return { ok: true, exitCode: result.exitCode, stdout: result.stdout };
+}
+
+async function handleUnregister(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    const tool = getDynamicTool(db, name);
+    if (!tool) {
+      logger.error(`Tool não encontrada: ${name}`);
+      return { ok: false, error: 'tool_not_found' };
+    }
+
+    unregisterDynamicTool(db, name);
+    logger.log(`Tool removida: ${name}`);
+    return { ok: true, name };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleShow(projectDir, options, logger) {
+  const name = String(options.name || '').trim();
+  if (!name) {
+    logger.error('--name é obrigatório');
+    return { ok: false, error: 'name_required' };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  try {
+    const tool = getDynamicTool(db, name);
+    if (!tool) {
+      logger.error(`Tool não encontrada: ${name}`);
+      return { ok: false, error: 'tool_not_found' };
+    }
+
+    logger.log(`Tool: ${tool.name}`);
+    logger.log(`Descrição: ${tool.description}`);
+    logger.log(`Tipo: ${tool.handler_type}`);
+    if (tool.handler_code) logger.log(`Comando: ${tool.handler_code}`);
+    if (tool.handler_path) logger.log(`Script: ${tool.handler_path}`);
+    if (tool.squad_slug) logger.log(`Squad: ${tool.squad_slug}`);
+    if (tool.registered_by) logger.log(`Registrada por: ${tool.registered_by}`);
+    logger.log(`Registrada em: ${tool.registered_at}`);
+
+    return { ok: true, tool };
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = { runToolRegistry };

package/src/commands/update.js

@@ -28,6 +28,9 @@ async function runUpdate({ args, options, logger, t }) {
       requestedLanguage ||
       (context.parsed && context.data && context.data.conversation_language
         ? context.data.conversation_language
+        : null) ||
+      (result.savedProfile && result.savedProfile.locale
+        ? result.savedProfile.locale
         : 'en');
     localeSync = await applyAgentLocale(targetDir, language, { dryRun });
   }
@@ -35,6 +38,10 @@ async function runUpdate({ args, options, logger, t }) {
   logger.log(t('update.done_at', { targetDir }));
   logger.log(t('update.files_updated', { count: result.copied.length }));
   logger.log(t('update.backups_created', { count: result.backedUp.length }));
+  if (!dryRun) {
+    logger.log('');
+    logger.log(t('update.reconfigure_hint'));
+  }
   if (localeSync) {
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeSync.locale }));

package/src/constants.js

@@ -33,6 +33,7 @@ const MANAGED_FILES = [
   '.aioson/agents/squad.md',
   '.aioson/agents/orache.md',
   '.aioson/agents/genome.md',
+  '.aioson/agents/design-hybrid-forge.md',
   '.aioson/agents/profiler-researcher.md',
   '.aioson/agents/profiler-enricher.md',
   '.aioson/agents/profiler-forge.md',
@@ -349,6 +350,14 @@ const AGENT_DEFINITIONS = [
     dependsOn: [],
     output: '.aioson/genomes/[slug].md + .aioson/genomes/[slug].meta.json + optional binding in .aioson/squads/{slug}/squad.md or .aioson/squads/{slug}/squad.manifest.json'
   },
+  {
+    id: 'design-hybrid-forge',
+    displayName: 'Design Hybrid Forge',
+    command: '@design-hybrid-forge',
+    path: '.aioson/agents/design-hybrid-forge.md',
+    dependsOn: ['.aioson/context/project.context.md'],
+    output: '.aioson/installed-skills/{hybrid-slug}/SKILL.md + .aioson/installed-skills/{hybrid-slug}/references/ + .aioson/installed-skills/{hybrid-slug}/previews/ + .aioson/installed-skills/{hybrid-slug}/.skill-meta.json'
+  },
   {
     id: 'profiler-researcher',
     displayName: 'Profiler Researcher',