multi-agents-cli 1.1.78 → 1.1.80

package/init.js

@@ -29,7 +29,7 @@ const {
   CLIENT_FRAMEWORKS,
   BACKEND_FRAMEWORKS,
   FRAMEWORK_VERSION_FALLBACK,
-  fetchLatestVersions,
+  fetchLatestVersions, prefetchVersions,
   STATE_OPTIONS,
   UI_OPTIONS,
   STYLING_OPTIONS,
@@ -38,6 +38,8 @@ const {
   ORM_OPTIONS,
   AUTH_OPTIONS,
   IDE_CANDIDATES,
+  BLOCK_CONFIG,
+  INTENT_MAP,
 } = require('./lib/data-config');
 
 const {
@@ -373,6 +375,44 @@ const main = async () => {
   steps.push(0, 'Project name', projectName);
   separator();
 
+  // ── Intent selection ────────────────────────────────────────────────────────
+  rl.pause();
+  const intentChoices = Object.entries(INTENT_MAP).map(([k, v]) => ({ label: v.label, value: k }));
+  const intentIdx = await arrowSelect('What would you like to build?', intentChoices);
+  const intentKey = intentChoices[intentIdx].value;
+  const intent    = INTENT_MAP[intentKey];
+
+  // Secondary prompt for fullstack order
+  let blockOrder = intent.blocks;
+  if (intentKey === 'fullstack') {
+    const orderIdx = await arrowSelect('Full-stack order?', [
+      { label: 'Client first, then backend' },
+      { label: 'Backend first, then client' },
+    ]);
+    blockOrder = orderIdx === 0 ? ['client', 'backend'] : ['backend', 'client'];
+  }
+
+  // Activate blocks and resolve absolute step indices
+  let absoluteStep = 0;
+  const blockEntries = [];
+  for (const blockKey of blockOrder) {
+    const block = BLOCK_CONFIG[blockKey];
+    block.isActive = true;
+    let isFirstSeg = true;
+    for (const [segKey, seg] of Object.entries(block)) {
+      if (segKey === 'isActive' || typeof seg !== 'object' || !('step' in seg)) continue;
+      seg.absoluteStep = absoluteStep;
+      if (isFirstSeg) { blockEntries.push(absoluteStep); isFirstSeg = false; }
+      absoluteStep++;
+    }
+  }
+  steps.blockEntries = blockEntries;
+
+  // Prefetch versions for active blocks in background
+  if (BLOCK_CONFIG.client.isActive) prefetchVersions(CLIENT_FRAMEWORKS);
+
+  separator();
+
   // Run all question steps with back-nav support
   const answers = await runQuestions(stepDefs, steps);
   if (answers === RESTART) {
@@ -389,7 +429,7 @@ const main = async () => {
   const clientUi             = answers.clientUi || null;
   const clientStyle          = answers.clientStyle || null;
   const useIntegratedBackend = answers.useIntegratedBackend || false;
-  const backendFwObj         = answers.backendFwObj || null;
+  const backendFwObj         = answers.backendFw || null;
   const backendFw            = backendFwObj ? fwValue(backendFwObj)    : null;
   const backendLang          = backendFwObj ? backendFwObj.language : null;
   const backendOrm           = answers.backendOrm || null;

package/lib/data-config.js

@@ -59,8 +59,8 @@ const FRAMEWORK_REGISTRY = {
   'Fastify':    { registry: 'npm',  package: 'fastify'            },
   'FastAPI':    { registry: 'pypi', package: 'fastapi'            },
   'Django':     { registry: 'pypi', package: 'django'             },
-  'Laravel':    { registry: 'npm',  package: null                 },
-  'Rails':      { registry: 'npm',  package: null                 },
+  'Laravel':    { registry: 'packagist', package: 'laravel/framework' },
+  'Rails':      { registry: 'rubygems',   package: 'rails'             },
 };
 
 const FRAMEWORK_VERSION_FALLBACK = {
@@ -79,21 +79,35 @@ const FRAMEWORK_VERSION_FALLBACK = {
   'Rails':      ['7.2', '7.1', '7.0'],
 };
 
+const _versionCache = {};
+
+const getVersionCache = (frameworkValue) => _versionCache[frameworkValue] || null;
+
+const prefetchVersions = (frameworks) => {
+  frameworks.forEach(fw => {
+    if (_versionCache[fw.value]) return;
+    fetchLatestVersions(fw.value).catch(() => {});
+  });
+};
+
 const fetchLatestVersions = async (frameworkValue) => {
+  if (_versionCache[frameworkValue]) return _versionCache[frameworkValue];
   const entry = FRAMEWORK_REGISTRY[frameworkValue];
   if (!entry || !entry.package) return null;
 
   try {
     const https = require('https');
-    const fetch = (url) => new Promise((resolve, reject) => {
-      const req = https.get(url, { timeout: 3000 }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => resolve(data));
-      });
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
-    });
+    const fetch = (url) => Promise.race([
+      new Promise((resolve, reject) => {
+        const req = https.get(url, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => resolve(data));
+        });
+        req.on('error', reject);
+      }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 2500)),
+    ]);
 
     if (entry.registry === 'npm') {
       const raw  = await fetch(`https://registry.npmjs.org/${entry.package}`);
@@ -104,7 +118,9 @@ const fetchLatestVersions = async (frameworkValue) => {
         .filter((v, i, arr) => arr.indexOf(v) === i)
         .sort((a, b) => b - a)
         .slice(0, 3);
-      return versions.length ? versions.map(String) : null;
+      const result = versions.length ? versions.map(String) : null;
+      if (result) _versionCache[frameworkValue] = result;
+      return result;
     }
 
     if (entry.registry === 'pypi') {
@@ -120,8 +136,37 @@ const fetchLatestVersions = async (frameworkValue) => {
         .map(v => v.split('.').slice(0, 2).join('.'))
         .filter((v, i, arr) => arr.indexOf(v) === i)
         .slice(0, 3);
-      return versions.length ? versions : null;
+      const result = versions.length ? versions : null;
+      if (result) _versionCache[frameworkValue] = result;
+      return result;
+    }
+    if (entry.registry === 'packagist') {
+      const raw  = await fetch(`https://packagist.org/packages/${entry.package}.json`);
+      const json = JSON.parse(raw);
+      const versions = Object.keys(json.package?.versions || {})
+        .filter(v => /^v?\d+\.\d+\.\d+$/.test(v) && !v.includes('-'))
+        .map(v => parseInt(v.replace(/^v/, '').split('.')[0]))
+        .filter((v, i, arr) => arr.indexOf(v) === i)
+        .sort((a, b) => b - a)
+        .slice(0, 3);
+      const result = versions.length ? versions.map(String) : null;
+      if (result) _versionCache[frameworkValue] = result;
+      return result;
+    }
+
+    if (entry.registry === 'rubygems') {
+      const raw  = await fetch(`https://rubygems.org/api/v1/versions/${entry.package}.json`);
+      const json = JSON.parse(raw);
+      const versions = json
+        .map(v => parseInt(v.number.split('.')[0]))
+        .filter((v, i, arr) => arr.indexOf(v) === i)
+        .sort((a, b) => b - a)
+        .slice(0, 3);
+      const result = versions.length ? versions.map(String) : null;
+      if (result) _versionCache[frameworkValue] = result;
+      return result;
     }
+
   } catch {
     return null;
   }
@@ -258,14 +303,45 @@ const BLOCKS = {
   SHARED:  'shared',
 };
 
+// ── Block config ─────────────────────────────────────────────────────────────
+
+const BLOCK_CONFIG = {
+  client: {
+    isActive: true,
+    framework:       { data: CLIENT_FRAMEWORKS, required: true,  key: 'clientFw',    step: 0 },
+    stateManagement: { data: STATE_OPTIONS,     required: false, key: 'clientState', step: 1 },
+    uiLibrary:       { data: UI_OPTIONS,        required: false, key: 'clientUi',    step: 2 },
+    styling:         { data: STYLING_OPTIONS,   required: false, key: 'clientStyle', step: 3 },
+  },
+  backend: {
+    isActive: false,
+    framework:       { data: BACKEND_FRAMEWORKS, required: false, key: 'backendFw',   step: 0 },
+    database:        { data: DB_OPTIONS,         required: false, key: 'backendDb',   step: 1 },
+    orm:             { data: ORM_OPTIONS,        required: false, key: 'backendOrm',  step: 2 },
+    auth:            { data: AUTH_OPTIONS,       required: false, key: 'backendAuth', step: 3 },
+  },
+};
+
+// ── Intent map ────────────────────────────────────────────────────────────────
+
+const INTENT_MAP = {
+  fullstack: { label: 'Full-stack',    blocks: ['client', 'backend'], order: null },
+  frontend:  { label: 'Frontend only', blocks: ['client'],            order: null },
+  backend:   { label: 'Backend only',  blocks: ['backend'],           order: null },
+};
+
 module.exports = {
   BLOCKS,
+  BLOCK_CONFIG,
+  INTENT_MAP,
   FRAMEWORK_CONVENTIONS,
   CLIENT_FRAMEWORKS,
   BACKEND_FRAMEWORKS,
   FRAMEWORK_REGISTRY,
   FRAMEWORK_VERSION_FALLBACK,
   fetchLatestVersions,
+  getVersionCache,
+  prefetchVersions,
   STATE_OPTIONS,
   UI_OPTIONS,
   STYLING_OPTIONS,

package/lib/questions-flow.js

@@ -2,12 +2,12 @@
 
 // ── Imports ───────────────────────────────────────────────────────────────────
 
-const { dim, bold, blue, green, cyan, separator, arrowSelect, arrowConfirm, selectRequired, selectOptional, stepHeader } = require('./ui');
+const { dim, bold, blue, green, cyan, separator, arrowSelect, arrowConfirm, selectRequired, selectOptional, stepHeader, createSpinner } = require('./ui');
 const { BLOCKS } = require('./data-config');
 const { BACK, RESTART } = require('./steps');
 const {
   CLIENT_FRAMEWORKS, BACKEND_FRAMEWORKS, FRAMEWORK_VERSION_FALLBACK,
-  fetchLatestVersions, STATE_OPTIONS, UI_OPTIONS, STYLING_OPTIONS,
+  fetchLatestVersions, getVersionCache, prefetchVersions, STATE_OPTIONS, UI_OPTIONS, STYLING_OPTIONS,
   DB_OPTIONS, ORM_OPTIONS_BY_DB, ORM_OPTIONS, AUTH_OPTIONS,
 } = require('./data-config');
 const { buildIDEOptions, verifyIDE, detectTerminal } = require('./detect');
@@ -36,10 +36,16 @@ const buildStepDefs = (IDE_CANDIDATES) => [
     run: async (machine, answers) => {
       stepHeader(2, 12);
       const fw = answers.clientFw;
-      const versions = await fetchLatestVersions(fwValue(fw)) || FRAMEWORK_VERSION_FALLBACK[fwValue(fw)] || [];
+      const cached = getVersionCache(fwValue(fw));
+      let versions;
+      if (cached) {
+        versions = cached;
+      } else {
+        const spinner = createSpinner('Fetching latest versions...');
+        versions = await fetchLatestVersions(fwValue(fw)) || FRAMEWORK_VERSION_FALLBACK[fwValue(fw)] || [];
+        spinner.stop();
+      }
       if (!versions.length) return null; // skip silently
-
-      console.log(dim('  Fetching latest versions...'));
       const versionChoices = versions.map((v, i) => ({
         label: i === 0 ? `v${v}  ${dim('(latest)')}` : `v${v}`,
         value: v,
@@ -105,25 +111,16 @@ const buildStepDefs = (IDE_CANDIDATES) => [
 
   // ── Step 6: Backend framework ────────────────────────────────────────────────
   {
-    name: 'backendFwObj',
+    name: 'backendFw',
     run: async (machine, answers) => {
-      stepHeader(7, 12);
       if (answers.useIntegratedBackend) return null; // skip
+      stepHeader(7, 12);
 
       separator();
       console.log(`\n${bold(blue('Backend configuration'))}`);
       console.log(dim('  You can skip the backend framework and decide later.\n'));
 
-      const choices = [
-        ...BACKEND_FRAMEWORKS.map(f => ({ label: f.label || f.value })),
-        { label: dim('Skip (decide later)') },
-      ];
-      const idx = await arrowSelect('Backend framework:', choices);
-
-      // Back nav
-      if (idx >= BACKEND_FRAMEWORKS.length + 1) return BACK;
-
-      return idx === BACKEND_FRAMEWORKS.length ? null : BACKEND_FRAMEWORKS[idx];
+      return await selectOptional('Backend framework:', BACKEND_FRAMEWORKS, machine, 6, answers, BLOCKS.BACKEND);
     },
   },
 
@@ -131,11 +128,19 @@ const buildStepDefs = (IDE_CANDIDATES) => [
   {
     name: 'backendFwVersion',
     run: async (machine, answers) => {
-      stepHeader(8, 12);
-      const fwObj = answers.backendFwObj;
+      const fwObj = answers.backendFw;
       if (!fwObj) return null; // skip — no backend selected
+      stepHeader(8, 12);
 
-      const versions = await fetchLatestVersions(fwValue(fwObj)) || FRAMEWORK_VERSION_FALLBACK[fwValue(fwObj)] || [];
+      const cached = getVersionCache(fwValue(fwObj));
+      let versions;
+      if (cached) {
+        versions = cached;
+      } else {
+        const spinner = createSpinner('Fetching latest versions...');
+        versions = await fetchLatestVersions(fwValue(fwObj)) || FRAMEWORK_VERSION_FALLBACK[fwValue(fwObj)] || [];
+        spinner.stop();
+      }
       if (!versions.length) return null;
 
       const vChoices = versions.map((v, i) => ({
@@ -158,8 +163,8 @@ const buildStepDefs = (IDE_CANDIDATES) => [
   {
     name: 'backendDb',
     run: async (machine, answers) => {
+      if (!answers.backendFw) return null;
       stepHeader(9, 12);
-      if (!answers.backendFwObj) return null;
       return await selectOptional('Database type:', DB_OPTIONS, machine, 8, answers, BLOCKS.BACKEND);
     },
   },
@@ -168,11 +173,11 @@ const buildStepDefs = (IDE_CANDIDATES) => [
   {
     name: 'backendOrm',
     run: async (machine, answers) => {
+      const { backendFw, backendDb } = answers;
+      if (!backendFw || !backendDb) return null;
       stepHeader(10, 12);
-      const { backendFwObj, backendDb } = answers;
-      if (!backendFwObj || !backendDb) return null;
       const byDb = ORM_OPTIONS_BY_DB[backendDb] || [];
-      const byFw = ORM_OPTIONS[fwValue(backendFwObj)] || [];
+      const byFw = ORM_OPTIONS[fwValue(backendFw)] || [];
       const ormChoices = byDb.length && byFw.length ? byDb.filter(o => byFw.includes(o)) : byDb.length ? byDb : byFw;
       return await selectOptional('ORM / query layer:', ormChoices, machine, 9, answers, BLOCKS.BACKEND);
     },
@@ -182,10 +187,10 @@ const buildStepDefs = (IDE_CANDIDATES) => [
   {
     name: 'backendAuth',
     run: async (machine, answers) => {
+      const { backendFw } = answers;
+      if (!backendFw) return null;
       stepHeader(11, 12);
-      const { backendFwObj } = answers;
-      if (!backendFwObj) return null;
-      return await selectOptional('Auth strategy:', AUTH_OPTIONS[fwValue(backendFwObj)] || [], machine, 10, answers, BLOCKS.BACKEND);
+      return await selectOptional('Auth strategy:', AUTH_OPTIONS[fwValue(backendFw)] || [], machine, 10, answers, BLOCKS.BACKEND);
     },
   },
 

package/lib/steps.js

@@ -10,10 +10,12 @@ const SHOW_LIST = Symbol('SHOW_LIST');
 // ── Step machine ──────────────────────────────────────────────────────────────
 
 class StepMachine {
-  constructor() {
+  constructor(blockEntries = []) {
     this.history      = []; // [{ stepIndex, stepName, answer }]
     this.inBackNav    = false;
     this.resumeIndex  = null; // step index where back-nav started
+    this.blockEntries = blockEntries; // absolute step indices that are block entry points
+    this.snapshot     = null; // history snapshot taken at back-nav start
   }
 
   // Push a completed step answer onto the history stack
@@ -63,11 +65,30 @@ class StepMachine {
     return opts;
   }
 
+  // Take a snapshot of current history + answers (for ignore-changes restore)
+  snapshotHistory() {
+    this.snapshot = this.history.map(h => ({ ...h }));
+  }
+
+  // Restore history from snapshot
+  restoreSnapshot() {
+    if (this.snapshot) {
+      this.history  = this.snapshot.map(h => ({ ...h }));
+      this.snapshot = null;
+    }
+  }
+
+  // Check if a step index is a block entry point
+  isBlockEntry(stepIndex) {
+    return this.blockEntries.includes(stepIndex);
+  }
+
   // Enter back-nav mode — record where the user first pressed Back
   enterBackNav(currentStepIndex) {
     if (!this.inBackNav) {
       this.inBackNav   = true;
       this.resumeIndex = currentStepIndex;
+      this.snapshotHistory();
     }
   }
 
@@ -82,6 +103,7 @@ class StepMachine {
     this.history     = [];
     this.inBackNav   = false;
     this.resumeIndex = null;
+    this.snapshot    = null;
   }
 }
 
@@ -106,9 +128,34 @@ const runQuestions = async (stepDefs, machine) => {
     if (result === BACK) {
       if (i === 0) return RESTART; // nowhere to go back from step 0
       machine.enterBackNav(i);     // record where back-nav started
+      i--;
+      // Skip back over auto-skipped steps (not in history), stop at block entry
+      while (i > 0 && !machine.history.find(h => h.stepIndex === i) && !machine.isBlockEntry(i)) i--;
+      // Pop the step we landed on
       const popped = machine.pop();
       if (popped) delete answers[popped.stepName];
-      i--;
+      // Block boundary checkpoint — fires when back-nav reaches a block entry point
+      if (machine.isBlockEntry(i)) {
+        const { arrowSelect } = require('./ui');
+        const boundaryChoice = await arrowSelect('You\'ve reached the start of this block.', [
+          { label: '→ Continue from here (re-answer this block)' },
+          { label: '→ Ignore changes (restore to where you started)' },
+          { label: '← Restart configuration' },
+        ]);
+        if (boundaryChoice === 1) {
+          const resumeTarget = machine.resumeIndex;
+          machine.restoreSnapshot();
+          Object.keys(answers).forEach(k => delete answers[k]);
+          machine.history.forEach(h => { answers[h.stepName] = h.answer; });
+          machine.exitBackNav();
+          const entryStep = machine.blockEntries.find(e => e <= i) ?? 0;
+          i = resumeTarget != null ? resumeTarget : entryStep + 1;
+
+        } else if (boundaryChoice === 2) {
+          return RESTART;
+        }
+        // 'continue' — just proceed from current block entry step
+      }
       continue;
     }
 

package/lib/ui.js

@@ -38,6 +38,22 @@ const rl = readline.createInterface({
 const ask = (question) =>
   new Promise((resolve) => rl.question(question, (a) => resolve(a.trim())));
 
+const createSpinner = (label) => {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  process.stdout.write(dim('  ' + label + ' '));
+  const timer = setInterval(() => {
+    process.stdout.write(String.fromCharCode(13) + dim('  ' + label + ' ' + frames[i % frames.length]));
+    i++;
+  }, 80);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      process.stdout.write(String.fromCharCode(13) + dim('  ' + label + ' done') + String.fromCharCode(10));
+    },
+  };
+};
+
 const arrowSelect = async (message, choices, showBack = false, backLabel = '← Restart configuration') => {
   const allChoices = showBack
     ? [...choices, { label: dim(backLabel) }]
@@ -241,7 +257,7 @@ module.exports = {
   stepHeader,
   c, bold, green, yellow, dim, cyan, blue, red,
   rl, ask,
-  arrowSelect, arrowConfirm,
+  arrowSelect, arrowConfirm, createSpinner,
   selectRequired, selectOptional,
   separator, showList, summaryLine, renderTrajectoryLines,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-agents-cli",
-  "version": "1.1.78",
+  "version": "1.1.80",
   "description": "Multi-agent workflow orchestration for Claude Code — isolated git worktrees, structured state tracking, autonomous task chaining",
   "keywords": [
     "claude-code",