plankit-cli 1.3.1 → 1.5.0

package/src/analyzer/vueScanner.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Fast static analyzer for Vue SFC (.vue) and JS/TS files.
+ * Uses lightweight block extraction and heuristic parsing without external dependencies.
+ */
+
+export function analyzeVueFile(filePath, content = null) {
+  const code = content !== null ? content : fs.readFileSync(filePath, 'utf8');
+  const lines = code.split(/\r?\n/);
+  const lineCount = lines.length;
+
+  const templateBlock = extractBlock(code, 'template');
+  const scriptBlock = extractBlock(code, 'script');
+  const styleBlocks = extractAllBlocks(code, 'style');
+
+  const isScriptSetup = /<script\s+[^>]*setup/i.test(code);
+  const hasScript = scriptBlock !== null || isScriptSetup;
+  const scriptContent = scriptBlock ? scriptBlock.content : '';
+  const scriptAttributes = scriptBlock ? scriptBlock.attributes : '';
+
+  // Language detection
+  const isTs = /lang=["'](?:ts|typescript)["']/i.test(code) ||
+    filePath.endsWith('.ts') ||
+    filePath.endsWith('.tsx');
+  const language = isTs ? 'ts' : 'js';
+
+  // Vue style detection (Options API, Composition API, or <script setup>)
+  let vueStyle = 'unknown';
+  if (isScriptSetup) {
+    vueStyle = 'script_setup';
+  } else if (hasScript) {
+    if (/\bsetup\s*\([^)]*\)\s*\{/i.test(scriptContent) || /\bdefineComponent\s*\(/i.test(scriptContent)) {
+      vueStyle = 'composition';
+    } else if (/\b(?:data\s*\(\)|methods\s*:|computed\s*:|watch\s*:)/i.test(scriptContent)) {
+      vueStyle = 'options';
+    } else {
+      vueStyle = 'transitional';
+    }
+  }
+
+  // State detection
+  const hasPinia = /\b(?:use\w+Store|defineStore)\b/i.test(code);
+  const hasVuex = /\b(?:this\.\$store|mapState|mapGetters|mapActions|mapMutations|createNamespacedHelpers)\b/i.test(code);
+  const hasComposable = /\buse(?!Store\b)\w+\s*\(/i.test(code);
+  const hasLocal = /\b(?:ref|reactive|shallowRef)\s*\(/i.test(code);
+
+  let state = 'local';
+  if (hasPinia && hasVuex) {
+    state = 'mixed';
+  } else if (hasPinia) {
+    state = 'pinia';
+  } else if (hasVuex) {
+    state = 'vuex';
+  } else if (hasComposable) {
+    state = 'composable';
+  } else if (hasLocal) {
+    state = 'local';
+  }
+
+  // Data access detection
+  let dataAccess = 'unknown';
+  if (/\baxios\.(?:get|post|put|delete|patch)\b/i.test(code)) {
+    dataAccess = 'axios_component';
+  } else if (/\buseQuery\b|\buseMutation\b/i.test(code)) {
+    dataAccess = 'query_library';
+  } else if (/\b(?:useFetch|\$fetch)\b/i.test(code)) {
+    dataAccess = 'fetch_composable';
+  } else if (/\b(?:api|service|client)\.\w+\b/i.test(code)) {
+    dataAccess = 'api_service';
+  }
+
+  // Styling analysis
+  const stylingTypes = new Set();
+  let hasScoped = false;
+  let hasGlobal = false;
+  for (const style of styleBlocks) {
+    const isScoped = /\bscoped\b/i.test(style.attributes);
+    const isModule = /\bmodule\b/i.test(style.attributes);
+    const isScss = /lang=["'](?:scss|sass)["']/i.test(style.attributes);
+
+    if (isModule) stylingTypes.add('modules');
+    if (isScoped) {
+      hasScoped = true;
+      stylingTypes.add(isScss ? 'scoped_scss' : 'scoped_css');
+    } else {
+      hasGlobal = true;
+      stylingTypes.add(isScss ? 'global_scss' : 'global_css');
+    }
+  }
+  if (templateBlock && /\bclass=["'][^"']*\b(?:flex|grid|p-|m-|text-|bg-|w-|h-)\b/i.test(templateBlock.content)) {
+    stylingTypes.add('utility');
+  }
+  const styling = stylingTypes.size > 0 ? Array.from(stylingTypes) : ['scoped_css'];
+
+  // Design token discovery (hex colors, font sizes, margins, padding)
+  const tokens = extractTokens(code);
+
+  // Anti-patterns and hotspots
+  const hotspots = [];
+  if (lineCount > 400) {
+    hotspots.push({ type: 'god_component', message: `Large SFC (${lineCount} lines)` });
+  }
+  if (/\b(?:this\.\$)/.test(code)) {
+    hotspots.push({ type: 'deprecated_global_property', message: 'Uses legacy this.$ properties' });
+  }
+  if (/::v-deep|>>>|\/deep\//.test(code)) {
+    hotspots.push({ type: 'deprecated_deep_selector', message: 'Uses deprecated deep CSS selector (::v-deep or /deep/)' });
+  }
+  if (/\bmixins\s*:\s*\[/i.test(code)) {
+    hotspots.push({ type: 'vue_mixins', message: 'Uses Vue mixins (replace with composables)' });
+  }
+  if (/\bfilters\s*:\s*\{/i.test(code)) {
+    hotspots.push({ type: 'vue_filters', message: 'Uses Vue 2 filters (not supported in Vue 3)' });
+  }
+  if (/\b\$on\b|\b\$emit\b.*eventBus|new\s+Vue\(\)/i.test(code)) {
+    hotspots.push({ type: 'event_bus', message: 'Uses global event bus' });
+  }
+
+  // Maturity classification
+  let maturity = 'preferred';
+  if (vueStyle === 'options' || hotspots.some((h) => h.type === 'vue_mixins' || h.type === 'vue_filters')) {
+    maturity = 'legacy';
+  } else if (vueStyle === 'composition' || language === 'js' || state === 'vuex' || hasGlobal) {
+    maturity = 'transitional';
+  } else if (vueStyle === 'script_setup' && language === 'ts') {
+    maturity = 'preferred';
+  }
+
+  return {
+    filePath,
+    fileName: path.basename(filePath),
+    lineCount,
+    language,
+    vueStyle,
+    state,
+    dataAccess,
+    styling,
+    hasScoped,
+    hasGlobal,
+    tokens,
+    hotspots,
+    maturity
+  };
+}
+
+function extractBlock(code, tag) {
+  const openRegex = new RegExp(`<${tag}(\\s+[^>]*)?>`, 'i');
+  const match = openRegex.exec(code);
+  if (!match) return null;
+
+  const startIndex = match.index + match[0].length;
+  const closeTag = `</${tag}>`;
+  const endIndex = code.indexOf(closeTag, startIndex);
+  if (endIndex === -1) {
+    return {
+      attributes: match[1] || '',
+      content: code.slice(startIndex)
+    };
+  }
+
+  return {
+    attributes: match[1] || '',
+    content: code.slice(startIndex, endIndex)
+  };
+}
+
+function extractAllBlocks(code, tag) {
+  const blocks = [];
+  const regex = new RegExp(`<${tag}(\\s+[^>]*)?>([\\s\\S]*?)<\\/${tag}>`, 'gi');
+  let match;
+  while ((match = regex.exec(code)) !== null) {
+    blocks.push({
+      attributes: match[1] || '',
+      content: match[2]
+    });
+  }
+  return blocks;
+}
+
+function extractTokens(code) {
+  const hexColors = new Set();
+  const hexRegex = /#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/g;
+  let match;
+  while ((match = hexRegex.exec(code)) !== null) {
+    hexColors.add(match[0].toLowerCase());
+  }
+
+  const spacingValues = new Set();
+  const spacingRegex = /(?:margin|padding|gap|top|bottom|left|right):\s*([0-9]+(?:px|rem|em))/gi;
+  while ((match = spacingRegex.exec(code)) !== null) {
+    spacingValues.add(match[1].toLowerCase());
+  }
+
+  return {
+    hexColors: Array.from(hexColors),
+    spacing: Array.from(spacingValues)
+  };
+}

package/src/cli.js

@@ -15,8 +15,16 @@ import {
   writeManagedFile
 } from './config.js';
 import { renderList, renderTemplate, packageRoot } from './templates.js';
-import { DEFAULT_AGENT, GEMINI_SKILL_ENTRIES, getAgent, listAgents, validAgentNames } from './agents.js';
-import { bundleEntry, bundleSourceExists } from './commandBundles.js';
+import { DEFAULT_AGENT, GEMINI_SKILL_ENTRIES, getAgent, listAgents, resolveAgentBundles, validAgentNames } from './agents.js';
+import {
+  SUPPORTED_FRAMEWORKS,
+  bundleEntry,
+  bundleSourceExists,
+  normalizeFramework,
+  parseFrameworksInput
+} from './commandBundles.js';
+import { runAnalysis, formatReport } from './analyzer/engine.js';
+import { loadDashboardData, renderStaticDashboard, runInteractiveDashboard } from './dashboard/dashboard.js';
 
 export async function runCli(args, context = {}) {
   const io = createIo(context);
@@ -44,6 +52,15 @@ export async function runCli(args, context = {}) {
       case 'status':
         showStatus(parsed, io);
         break;
+      case 'scan':
+      case 'health':
+      case 'audit':
+        await scanRepository(parsed, io);
+        break;
+      case 'ui':
+      case 'dashboard':
+        await showDashboard(parsed, io);
+        break;
       case 'archive':
         archiveFeature(parsed, io);
         break;
@@ -71,6 +88,7 @@ async function initProject(parsed, io) {
   const { config, path: configPath } = loadConfig(io.cwd);
   const options = writeOptions(parsed, config);
   const agent = await resolveAgent(parsed, config, io, configPath);
+  const frameworks = await resolveFrameworks(parsed, config, io, configPath);
   const results = [];
   const artifactsDir = safeJoin(io.cwd, config.artifactsDir);
 
@@ -84,7 +102,7 @@ async function initProject(parsed, io) {
   ));
   results.push(writeManagedFile(path.join(artifactsDir, 'current', '.gitkeep'), '', options));
   results.push(writeManagedFile(path.join(artifactsDir, 'archived', '.gitkeep'), '', options));
-  results.push(createDefaultConfigFile(io.cwd, options));
+  results.push(createDefaultConfigFile(io.cwd, options, frameworks));
 
   for (const binding of agent.bindings) {
     results.push(writeManagedFile(
@@ -94,7 +112,8 @@ async function initProject(parsed, io) {
     ));
   }
 
-  for (const bundleName of agent.commandBundles) {
+  const bundlesToInstall = resolveAgentBundles(agent.id, frameworks);
+  for (const bundleName of bundlesToInstall) {
     results.push(installCommandBundle(agent, bundleName, config, options, io));
   }
 
@@ -102,7 +121,10 @@ async function initProject(parsed, io) {
     results.push(...installGlobalGeminiSkills(config, options));
   }
 
-  io.stdout(`PlanKit initialized for agent "${agent.id}".`);
+  const fwMsg = frameworks.length > 0
+    ? ` with framework suite(s): ${frameworks.join(', ')}`
+    : ' (base planning commands only)';
+  io.stdout(`PlanKit initialized for agent "${agent.id}"${fwMsg}.`);
   printResults(results, io);
 }
 
@@ -354,6 +376,49 @@ function archiveFeature(parsed, io) {
   io.stdout(`Feature "${featureName}" archived.`);
 }
 
+async function scanRepository(parsed, io) {
+  const { config } = loadConfig(io.cwd);
+  const targetDir = parsed.positionals[0] ? path.resolve(io.cwd, parsed.positionals[0]) : io.cwd;
+  const report = await runAnalysis(targetDir, {
+    artifactsDir: config.artifactsDir
+  });
+
+  if (parsed.flags.json) {
+    io.stdout(JSON.stringify(report, null, 2));
+  } else {
+    io.stdout(formatReport(report, io.isTTY));
+  }
+
+  if (parsed.flags.threshold) {
+    const threshold = Number.parseInt(parsed.flags.threshold, 10);
+    if (Number.isInteger(threshold) && report.score.total < threshold) {
+      throw new Error(`Health score ${report.score.total} is below required threshold ${threshold}`);
+    }
+  }
+}
+
+async function showDashboard(parsed, io) {
+  const { config } = loadConfig(io.cwd);
+  const data = loadDashboardData(io.cwd, config);
+
+  if (!io.isTTY || parsed.flags['no-tui']) {
+    renderStaticDashboard(data, io);
+    return;
+  }
+
+  await runInteractiveDashboard(io.cwd, io, config, {
+    implement: async (featureName, phaseNum) => {
+      prepareImplementation({ positionals: [featureName, String(phaseNum)], flags: {} }, io);
+    },
+    clarify: async (featureName) => {
+      clarifyFeature({ positionals: [featureName], flags: {} }, io);
+    },
+    review: async (featureName) => {
+      reviewFeature({ positionals: [featureName], flags: { 'skip-test': true, 'skip-build': true } }, io);
+    }
+  });
+}
+
 function moveFeatureToArchive(cwd, config, featureName, dryRun = false) {
   const sourceDir = requireFeatureDir(cwd, config, featureName);
   const targetDir = safeJoin(cwd, config.artifactsDir, 'archived', featureName);
@@ -522,6 +587,93 @@ async function promptAgent(io) {
   return getAgent(trimmed) || null;
 }
 
+async function resolveFrameworks(parsed, config, io, configPath = null) {
+  const fromFlag = parsed.flags.framework || parsed.flags.frameworks;
+  if (fromFlag !== undefined) {
+    const frameworks = parseFrameworksInput(fromFlag);
+    if (frameworks.length > 0) {
+      io.stdout(`Using framework(s) from --framework flag: "${frameworks.join(', ')}".`);
+    } else {
+      io.stdout('No framework suites selected via --framework flag.');
+    }
+    return frameworks;
+  }
+
+  if (configPath && Array.isArray(config.frameworks) && config.frameworks.length > 0) {
+    io.stdout(`Using configured framework(s) "${config.frameworks.join(', ')}" from plan config.`);
+    return config.frameworks;
+  }
+
+  if (io.isTTY && io.promptChoice) {
+    const selected = await promptFrameworks(io);
+    if (selected !== null) {
+      if (selected.length > 0) {
+        io.stdout(`Selected framework(s): "${selected.join(', ')}".`);
+      } else {
+        io.stdout('Selected base planning commands only.');
+      }
+      return selected;
+    }
+  }
+
+  io.stdout('No framework suite selected — installing base planning commands only. Pass --framework <angular|vue|dotnet|none> to add framework suites.');
+  return [];
+}
+
+async function promptFrameworks(io) {
+  const promptText = `Select framework command suites to install (in addition to base planning commands):
+  1. None (Base planning commands only)
+  2. Angular command suite
+  3. Vue modernization & architecture suite
+  4. .NET clean architecture & API suite
+  5. All framework suites
+
+Enter a number (1-5), comma-separated numbers, or framework names (default: 1)`;
+
+  const validChoices = ['1', '2', '3', '4', '5', 'none', 'angular', 'vue', 'dotnet', 'all'];
+  const answer = await io.promptChoice(promptText, validChoices);
+  if (!answer || !answer.trim()) {
+    return [];
+  }
+
+  const raw = answer.trim().toLowerCase();
+  const tokens = raw.split(',').map((t) => t.trim()).filter(Boolean);
+  const result = new Set();
+
+  for (const token of tokens) {
+    if (token === '1' || token === 'none') {
+      continue;
+    }
+    if (token === '2' || token === 'angular' || token === 'ng') {
+      result.add('angular');
+      continue;
+    }
+    if (token === '3' || token === 'vue' || token === 'vuejs') {
+      result.add('vue');
+      continue;
+    }
+    if (token === '4' || token === 'dotnet' || token === '.net' || token === 'net') {
+      result.add('dotnet');
+      continue;
+    }
+    if (token === '5' || token === 'all') {
+      SUPPORTED_FRAMEWORKS.forEach((fw) => result.add(fw));
+      continue;
+    }
+
+    const normalized = normalizeFramework(token);
+    if (Array.isArray(normalized)) {
+      normalized.forEach((fw) => result.add(fw));
+    } else if (normalized) {
+      result.add(normalized);
+    } else {
+      throw new Error(`Unknown framework selection "${token}". Valid options: 1-5, ${SUPPORTED_FRAMEWORKS.join(', ')}, none, all.`);
+    }
+  }
+
+  return Array.from(result);
+}
+
 function writeOptions(parsed, config) {
   return {
     force: Boolean(parsed.flags.force) || config.overwrite === 'force',
@@ -636,6 +788,8 @@ Commands:
   implement <feature> <phase>       Validate phase context and prepare phase output artifact
   review <feature>                  Run verification and archive a completed feature
   status [--json]                   Show active and archived features
+  scan [dir]                        Run static analysis and generate artifacts/.plankit-index.json
+  ui                                Launch interactive feature progress dashboard
   archive <feature>                 Move a feature to archived without running verification
   version                          Show the installed PlankKit CLI version
   help                              Show this help message
@@ -645,6 +799,12 @@ Options:
   --dry-run                         Show intended actions without writing
   --agent <name>                    Select your coding agent during init
                                     (opencode, gemini, codex, cursor; default: opencode)
+  --framework <name>                Select framework command suite during init
+                                    (angular, vue, dotnet, none, all; default: none)
+  --frameworks <list>               Comma-separated list of framework suites during init
+  --threshold <score>               Fail scan if health score is below threshold
+  --json                            Output scan report or status as JSON
+  --no-tui                          Render static summary table instead of interactive dashboard
   --global-gemini-skills            Also install Gemini skills under the user profile
   --phases 3                        Generate N default phases during plan
   --phases "Design,Build,Test"      Generate named phases during plan

package/src/commandBundles.js

@@ -4,6 +4,24 @@ import fs from 'node:fs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
+export const SUPPORTED_FRAMEWORKS = ['angular', 'vue', 'dotnet'];
+
+export const FRAMEWORK_ALIASES = {
+  ng: 'angular',
+  angular: 'angular',
+  vue: 'vue',
+  vuejs: 'vue',
+  dotnet: 'dotnet',
+  net: 'dotnet',
+  '.net': 'dotnet'
+};
+
+export const FRAMEWORK_DESCRIPTIONS = {
+  angular: 'Angular command suite',
+  vue: 'Vue modernization & architecture suite',
+  dotnet: '.NET clean architecture & API suite'
+};
+
 export const COMMAND_BUNDLES = {
   'opencode-angular': {
     label: 'Angular command suite',
@@ -28,13 +46,100 @@ export const COMMAND_BUNDLES = {
     src: path.join('angular-commands', 'cursor'),
     dest: ['.cursor', 'rules'],
     kind: 'folder'
+  },
+  'opencode-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-vue': {
+    label: 'Vue skill suite',
+    src: path.join('vue-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
+  },
+  'opencode-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-dotnet': {
+    label: '.NET skill suite',
+    src: path.join('dotnet-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
   }
 };
 
+export function normalizeFramework(input) {
+  if (!input) return null;
+  const cleaned = String(input).trim().toLowerCase();
+  if (cleaned === 'none') return null;
+  if (cleaned === 'all') return [...SUPPORTED_FRAMEWORKS];
+  return FRAMEWORK_ALIASES[cleaned] || null;
+}
+
+export function parseFrameworksInput(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return input.flatMap((item) => parseFrameworksInput(item));
+  }
+  const parts = String(input)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  const frameworks = new Set();
+  for (const part of parts) {
+    const normalized = normalizeFramework(part);
+    if (Array.isArray(normalized)) {
+      normalized.forEach((fw) => frameworks.add(fw));
+    } else if (normalized) {
+      frameworks.add(normalized);
+    } else if (part.toLowerCase() === 'none') {
+      // explicit none
+      continue;
+    } else {
+      throw new Error(`Unknown framework "${part}". Valid frameworks: ${SUPPORTED_FRAMEWORKS.join(', ')}, none, all.`);
+    }
+  }
+  return Array.from(frameworks);
+}
+
 export function bundleEntry(bundleName) {
   return COMMAND_BUNDLES[bundleName] || null;
 }
 
+export function bundleNameFor(agentId, framework) {
+  return `${agentId}-${framework}`;
+}
+
 export function bundleSourceExists(bundleName, cwd, config) {
   const entry = COMMAND_BUNDLES[bundleName];
   if (!entry) {

package/src/config.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { AGENT_ORDER, DEFAULT_AGENT, getAgent } from './agents.js';
+import { parseFrameworksInput } from './commandBundles.js';
 
 export const DEFAULT_CONFIG = {
   artifactsDir: 'artifacts',
@@ -8,6 +9,7 @@ export const DEFAULT_CONFIG = {
   agents: {
     default: DEFAULT_AGENT
   },
+  frameworks: [],
   defaultPhases: [
     {
       title: 'Foundation & Setup',
@@ -57,9 +59,13 @@ export function loadConfig(cwd = process.cwd()) {
   };
 }
 
-export function createDefaultConfigFile(cwd, options = {}) {
+export function createDefaultConfigFile(cwd, options = {}, frameworks = []) {
   const filePath = path.join(cwd, 'plankit.config.json');
-  const content = `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`;
+  const baseConfig = structuredClone(DEFAULT_CONFIG);
+  if (Array.isArray(frameworks) && frameworks.length > 0) {
+    baseConfig.frameworks = frameworks;
+  }
+  const content = `${JSON.stringify(baseConfig, null, 2)}\n`;
   return writeManagedFile(filePath, content, options);
 }
 
@@ -69,10 +75,22 @@ export function normalizeConfig(config) {
   normalized.artifactsDir = normalized.artifactsDir || DEFAULT_CONFIG.artifactsDir;
   normalized.overwrite = normalized.overwrite || DEFAULT_CONFIG.overwrite;
   normalized.agents = normalizeAgents(normalized.agents);
+  normalized.frameworks = normalizeFrameworksConfig(normalized.frameworks);
   normalized.verification = { ...DEFAULT_CONFIG.verification, ...(normalized.verification || {}) };
   return normalized;
 }
 
+export function normalizeFrameworksConfig(frameworks) {
+  if (!frameworks) return [];
+  if (Array.isArray(frameworks)) {
+    return parseFrameworksInput(frameworks);
+  }
+  if (typeof frameworks === 'string') {
+    return parseFrameworksInput(frameworks);
+  }
+  return [];
+}
+
 export function normalizeAgents(agents) {
   if (!agents || typeof agents !== 'object') {
     return { ...DEFAULT_CONFIG.agents };