viepilot 2.50.1 → 3.7.2

package/lib/adapter-context.cjs

@@ -0,0 +1,294 @@
+'use strict';
+
+/**
+ * ADAPTER_CONTEXT — per-adapter capability map for ViePilot v3.
+ *
+ * Each adapter entry defines:
+ *   tools{}          — canonical tool name for each abstract operation
+ *   interactive      — "AUQ" | "text" | "text-plan-only" | "none"
+ *   orchestration{}  — parallel dispatch capability
+ *   hooks{}          — hook event support
+ *   mcp{}            — MCP support constraints
+ *   subagent         — "multi-level" | "single-level" | "command-only" | "none"
+ *
+ * Skills read ADAPTER_CONTEXT instead of maintaining inline compat tables.
+ */
+
+const ADAPTER_CONTEXTS = {
+
+  'claude-code': {
+    id: 'claude-code',
+    name: 'Claude Code',
+    tools: {
+      shell:        'Bash',
+      read:         'Read',
+      write:        'Write',
+      edit:         'Edit',
+      multi_edit:   'MultiEdit',
+      search:       'Grep',
+      glob:         'Glob',
+      ls:           'LS',
+      web_search:   'WebSearch',
+      web_fetch:    'WebFetch',
+      notebook_read: 'NotebookRead',
+      notebook_edit: 'NotebookEdit',
+      tool_search:  'ToolSearch',
+      todo_read:    'TodoRead',
+      todo_write:   'TodoWrite',
+      agent:        'Agent',
+      interactive:  'AskUserQuestion',   // deferred — preload via ToolSearch first
+    },
+    interactive:  'AUQ',               // must call ToolSearch before first AUQ
+    subagent:     'multi-level',        // Agent tool supports nested spawning
+    orchestration: {
+      mode:            'agent-tool',    // Agent tool = callable from skill
+      parallel:        true,
+      teams:           true,            // CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
+      background:      true,
+      model_override:  {
+        worker:        'claude-haiku-4-5',
+        orchestrator:  'claude-sonnet-4-6',
+      },
+      max_parallel_tasks: 5,
+    },
+    hooks: {
+      count: 28,
+      supported_events: [
+        'SessionStart', 'SessionEnd', 'Stop', 'StopFailure',
+        'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure',
+        'FileChanged', 'SubagentStart', 'SubagentStop',
+        'TaskCreated', 'TaskCompleted', 'PreCompact', 'PostCompact',
+      ],
+    },
+    mcp: { supported: true, tool_limit: null },
+    skill_path_project: '.claude/skills',
+    skill_path_global:  '~/.claude/skills',
+    agents_dir: '.claude/agents',
+  },
+
+  'cursor-agent': {
+    id: 'cursor-agent',
+    name: 'Cursor (Agent Mode)',
+    tools: {
+      shell:        'run_terminal_cmd',
+      read:         'read_file',
+      write:        'edit_file',
+      edit:         'edit_file',
+      multi_edit:   'edit_file',
+      search:       'grep_search',
+      glob:         'file_search',
+      ls:           'list_dir',
+      web_search:   'web_search',
+      web_fetch:    null,              // not available
+      notebook_read: null,
+      notebook_edit: null,
+      tool_search:  null,
+      todo_read:    null,
+      todo_write:   null,
+      agent:        null,              // /multitask is user command, not callable tool
+      interactive:  null,              // AskQuestion only in Plan Mode
+    },
+    interactive:  'text',              // plain-text numbered list fallback
+    subagent:     'command-only',      // /multitask user cmd, single-level, not callable
+    orchestration: {
+      mode:            'sequential',
+      parallel:        false,
+      teams:           false,
+      background:      false,
+      model_override:  null,
+      max_parallel_tasks: 1,
+    },
+    hooks: {
+      count: 5,
+      supported_events: [
+        'beforeShellExecution', 'beforeMCPExecution',
+        'beforeReadFile', 'afterFileEdit', 'stop',
+      ],
+    },
+    mcp: { supported: true, tool_limit: 40 },
+    skill_path_project: '.cursor/skills',
+    skill_path_global:  '~/.cursor/skills',
+    agents_dir: null,
+  },
+
+  'antigravity': {
+    id: 'antigravity',
+    name: 'Antigravity (Google)',
+    tools: {
+      shell:        'shell',
+      read:         'file_read',
+      write:        'file_write',
+      edit:         'file_write',
+      multi_edit:   'file_write',
+      search:       null,              // via shell or MCP
+      glob:         null,              // via shell
+      ls:           null,              // via shell
+      web_search:   null,              // via MCP plugin
+      web_fetch:    null,              // via MCP plugin
+      notebook_read: null,
+      notebook_edit: null,
+      tool_search:  null,
+      todo_read:    null,
+      todo_write:   null,
+      agent:        null,              // async TUI dispatch only
+      interactive:  null,             // TUI-based, no formal AUQ
+    },
+    interactive:  'none',
+    subagent:     'none',
+    orchestration: {
+      mode:            'sequential',
+      parallel:        false,
+      teams:           false,
+      background:      false,
+      model_override:  null,
+      max_parallel_tasks: 1,
+    },
+    hooks: {
+      count: 3,
+      supported_events: ['before_tool', 'after_file_edit', 'session_start'],
+    },
+    mcp: { supported: true, tool_limit: null },
+    skill_path_project: '.agents/skills',
+    skill_path_global:  '~/.gemini/antigravity/skills',
+    agents_dir: null,
+    deprecation_notice: 'Gemini CLI was deprecated June 18, 2026. Use Antigravity CLI instead.',
+  },
+
+  'codex': {
+    id: 'codex',
+    name: 'OpenAI Codex CLI',
+    tools: {
+      shell:        'container.exec',  // sandboxed shell
+      read:         null,              // patch-based — no explicit read tool
+      write:        'apply_patch',
+      edit:         'apply_patch',
+      multi_edit:   'apply_patch',
+      search:       null,              // via shell
+      glob:         null,              // via shell
+      ls:           null,              // via shell
+      web_search:   'web_search',      // native or MCP
+      web_fetch:    null,
+      notebook_read: null,
+      notebook_edit: null,
+      tool_search:  null,
+      todo_read:    null,
+      todo_write:   null,
+      agent:        'subagent',        // subagents supported
+      interactive:  null,             // TUI Tab/Enter injection only
+    },
+    interactive:  'none',
+    subagent:     'single-level',
+    orchestration: {
+      mode:            'sequential',
+      parallel:        false,
+      teams:           false,
+      background:      false,
+      model_override:  null,
+      max_parallel_tasks: 1,
+    },
+    hooks: {
+      count: 0,
+      supported_events: [],
+    },
+    mcp: { supported: true, tool_limit: null },
+    skill_path_project: null,
+    skill_path_global:  '~/.codex',
+    agents_dir: null,
+  },
+
+  'copilot': {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    tools: {
+      shell:        'runCommands',
+      read:         'read',
+      write:        'editFiles',
+      edit:         'edit',
+      multi_edit:   'editFiles',
+      search:       'code_search',
+      glob:         null,
+      ls:           null,
+      web_search:   null,
+      web_fetch:    null,
+      notebook_read: null,
+      notebook_edit: null,
+      tool_search:  null,
+      todo_read:    null,
+      todo_write:   null,
+      agent:        null,             // explore/task are built-in agents, not callable
+      // askQuestions available in main agent ONLY — not in subagents (VS Code #293745)
+      interactive:  'askQuestions',
+    },
+    interactive:  'text',             // askQuestions not available in subagents
+    subagent:     'none',
+    orchestration: {
+      mode:            'sequential',
+      parallel:        false,
+      teams:           false,
+      background:      false,
+      model_override:  null,
+      max_parallel_tasks: 1,
+    },
+    hooks: {
+      count: 0,
+      supported_events: [],
+    },
+    mcp: { supported: true, tool_limit: null },
+    skill_path_project: '.github/agents',
+    skill_path_global:  null,
+    agents_dir: '.github/agents',
+  },
+};
+
+// Aliases
+ADAPTER_CONTEXTS['cursor'] = ADAPTER_CONTEXTS['cursor-agent'];
+ADAPTER_CONTEXTS['cursor-ide'] = ADAPTER_CONTEXTS['cursor-agent'];
+
+/**
+ * Get ADAPTER_CONTEXT for a given adapter ID. Throws if unknown.
+ */
+function getAdapterContext(id) {
+  const ctx = ADAPTER_CONTEXTS[id];
+  if (!ctx) {
+    throw new Error(`Unknown adapter: "${id}". Known: ${Object.keys(ADAPTER_CONTEXTS).filter(k => !['cursor','cursor-ide'].includes(k)).join(', ')}`);
+  }
+  return ctx;
+}
+
+/**
+ * List all canonical adapter IDs (no aliases).
+ */
+function listAdapterIds() {
+  return ['claude-code', 'cursor-agent', 'antigravity', 'codex', 'copilot'];
+}
+
+/**
+ * Detect the active adapter from environment heuristics.
+ * Returns the adapter ID string.
+ */
+function detectAdapter() {
+  const env = process.env;
+
+  // Env-var signals (strongest signals first)
+  if (env.CURSOR_TRACE || env.CURSOR_CHANNEL || env.CURSOR_ENABLED) return 'cursor-agent';
+  if (env.ANTIGRAVITY_SESSION || env.GEMINI_ANTIGRAVITY_SESSION) return 'antigravity';
+  if (env.CODEX_SESSION || env.OPENAI_CODEX_SESSION) return 'codex';
+  if (env.GITHUB_COPILOT_AGENT || env.COPILOT_AGENT) return 'copilot';
+
+  // TERM_PROGRAM / process name signals
+  const termProgram = (env.TERM_PROGRAM || '').toLowerCase();
+  if (termProgram === 'claude' || termProgram === 'claude-code') return 'claude-code';
+
+  // ~/.claude directory exists → likely Claude Code
+  const os = require('os');
+  const fs = require('fs');
+  const path = require('path');
+  const home = os.homedir();
+  if (fs.existsSync(path.join(home, '.claude', 'settings.json'))) return 'claude-code';
+  if (fs.existsSync(path.join(home, '.claude'))) return 'claude-code';
+
+  // Fallback: claude-code (most common in ViePilot context)
+  return 'claude-code';
+}
+
+module.exports = { ADAPTER_CONTEXTS, getAdapterContext, listAdapterIds, detectAdapter };

package/lib/adapters/antigravity.cjs

@@ -6,16 +6,21 @@ const fs = require('fs');
 module.exports = {
   id: 'antigravity',
   name: 'Antigravity',
+  // Global install path (unchanged)
   skillsDir:   (home) => path.join(home, '.gemini', 'antigravity', 'skills'),
   viepilotDir: (home) => path.join(home, '.gemini', 'antigravity', 'viepilot'),
+  // Phase 131 (FEAT-021): project-level install path (Antigravity v1 uses .agents/skills/)
+  projectSkillsDir: '.agents/skills',
   // {envToolDir} in SKILL.md files resolves to this value at install time (ENH-035)
   executionContextBase: '.gemini/antigravity/viepilot',
   // Post-install hint shown in "Next actions" after viepilot install
   postInstallHint: 'Open project and run /vp-status',
+  // Phase 131 (FEAT-021): Gemini CLI was deprecated June 18, 2026
+  deprecationNotice: '⚠️  Gemini CLI was deprecated June 18, 2026. This installs for Antigravity CLI (the successor). Skill path: .agents/skills/ (project) or ~/.gemini/antigravity/skills/ (global).',
   hooks: {
     configFile: null,       // Antigravity has no programmatic hooks system
     schema: 'antigravity',
-    supportedEvents: []
+    supportedEvents: ['before_tool', 'after_file_edit', 'session_start']
   },
   installSubdirs: [
     'workflows',
@@ -30,6 +35,7 @@ module.exports = {
   isAvailable: (home) => {
     const h = home || os.homedir();
     return fs.existsSync(path.join(h, '.gemini', 'antigravity'))
-      || fs.existsSync(path.join(h, '.antigravity'));
+      || fs.existsSync(path.join(h, '.antigravity'))
+      || fs.existsSync(path.join(process.cwd(), '.agents'));
   }
 };

package/lib/adapters/claude-code.cjs

@@ -35,6 +35,10 @@ module.exports = {
     'ui-components',
     'agents'
   ],
+  // Phase 130 (FEAT-021): native Claude Code subagent definitions (.claude/agents/)
+  // Installed to ~/.claude/agents/ (Claude Code's native agent directory)
+  claudeAgentsDir: (home) => path.join(home, '.claude', 'agents'),
+  claudeAgentsSrc: 'agents/claude-code',
   // Detection: is this platform available on the current machine?
   isAvailable: (home) => {
     const h = home || os.homedir();

package/lib/audit/browser-runner.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const DEFAULT_BASE_URL = 'http://localhost:3000';
+
+/**
+ * Resolve base URL for browser audit.
+ * Priority: options.baseUrl → config.json audit.baseUrl → DEFAULT_BASE_URL
+ * @param {object} options - { baseUrl?: string }
+ * @param {string} projectRoot
+ * @returns {string}
+ */
+function resolveBaseUrl(options, projectRoot) {
+  if (options && options.baseUrl) return options.baseUrl;
+  try {
+    const configPath = path.join(projectRoot, '.viepilot', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (cfg.audit && cfg.audit.baseUrl) return cfg.audit.baseUrl;
+    }
+  } catch { /* config missing or malformed — use default */ }
+  return DEFAULT_BASE_URL;
+}
+
+/**
+ * Write a Markdown audit report to .viepilot/audit/visual-report-{timestamp}.md
+ * @param {object} report - structured audit report from browser-audit-agent
+ * @param {string} projectRoot
+ * @returns {string} absolute path to report file
+ */
+function writeAuditReport(report, projectRoot) {
+  const auditDir = path.join(projectRoot, '.viepilot', 'audit');
+  fs.mkdirSync(auditDir, { recursive: true });
+
+  const timestamp = Date.now();
+  const reportPath = path.join(auditDir, `visual-report-${timestamp}.md`);
+
+  const routes = report.routes || [];
+  const routeTable = routes.map(r => {
+    const status = r.status === 'ok' ? '✅ ok' : `❌ ${r.status}`;
+    const issues = (r.errors && r.errors.length > 0) ? r.errors.join(', ') : '—';
+    return `| ${r.url} | ${status} | ${issues} |`;
+  }).join('\n');
+
+  const accessibilitySection = routes
+    .filter(r => r.accessibility_issues && r.accessibility_issues.length > 0)
+    .map(r => `### ${r.url}\n${r.accessibility_issues.map(i => `- **${i.type}**: ${i.description}`).join('\n')}`)
+    .join('\n\n') || '_No accessibility issues found._';
+
+  const screenshotSection = routes
+    .filter(r => r.screenshot)
+    .map(r => `- \`${r.url}\`: \`${r.screenshot}\``)
+    .join('\n') || '_No screenshots captured._';
+
+  const content = `# Browser Audit Report — ${new Date(timestamp).toISOString()}
+
+**Base URL**: ${report.baseUrl || DEFAULT_BASE_URL}
+**Routes checked**: ${routes.length}
+**Op**: ${report.op || 'audit_routes'}
+
+## Routes
+
+| Route | Status | Issues |
+|-------|--------|--------|
+${routeTable}
+
+## Accessibility Issues
+
+${accessibilitySection}
+
+## Screenshots
+
+${screenshotSection}
+`;
+
+  fs.writeFileSync(reportPath, content, 'utf8');
+  return reportPath;
+}
+
+/**
+ * Run browser audit by dispatching browser-audit-agent (CC adapter only).
+ * On non-CC: throws with install instructions.
+ * @param {object} options - { baseUrl?, routes?, op?, updateBaseline? }
+ * @param {string} projectRoot
+ * @returns {Promise<object>} - report object
+ */
+async function runBrowserAudit(options, projectRoot) {
+  const baseUrl = resolveBaseUrl(options, projectRoot);
+  const op = (options && options.op) || 'audit_routes';
+
+  // CC adapter: Agent dispatch is handled by vp-audit SKILL.md (orchestrator layer).
+  // This module is for direct Node callers — emit clear error.
+  throw new Error(
+    `Browser audit requires Claude Code with the agent-browser skill.\n` +
+    `Install: npx skills add vercel-labs/agent-browser\n` +
+    `Then run: /vp-audit --visual --browser ${baseUrl}`
+  );
+}
+
+module.exports = { runBrowserAudit, resolveBaseUrl, writeAuditReport, DEFAULT_BASE_URL };

package/lib/intake/adapters/browser.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+const URL_PATTERNS = {
+  'google-sheets':   /docs\.google\.com\/spreadsheets/,
+  'github-issues':   /github\.com\/[^/]+\/[^/]+\/issues/,
+  'jira':            /atlassian\.net\/browse\/[A-Z]+-\d+|atlassian\.net\/jira\/software\/projects/,
+  'trello':          /trello\.com\/[bc]\//,
+  'notion':          /notion\.so\/[a-f0-9]{8,}/,
+  'sharepoint-xlsx': /sharepoint\.com\/:[a-z]:\/[a-z]\//,
+};
+
+/**
+ * Detect source type from URL string.
+ * @param {string} url
+ * @returns {'google-sheets'|'github-issues'|'jira'|'trello'|'notion'|'sharepoint-xlsx'|'generic-table'}
+ */
+function detectUrlType(url) {
+  if (!url || typeof url !== 'string') return 'generic-table';
+  for (const [type, pattern] of Object.entries(URL_PATTERNS)) {
+    if (pattern.test(url)) return type;
+  }
+  return 'generic-table';
+}
+
+/**
+ * Read ticket rows from a public URL via browser-intake-agent (CC adapter only).
+ * Non-CC adapters receive a clear unsupported error.
+ * @param {object} channel - channel config with `url` field
+ * @param {string} projectRoot - absolute path to project root
+ * @returns {Promise<Array<{title,description,labels,priority,status}>>}
+ */
+async function readBrowserUrl(channel, projectRoot) {
+  if (!channel || !channel.url) {
+    throw new Error('browser channel requires a "url" field in channel config');
+  }
+
+  const sourceType = detectUrlType(channel.url);
+
+  // CC adapter: Agent dispatch is handled by vp-intake SKILL.md (orchestrator layer).
+  // This module is used by non-CC adapters or direct Node callers — emit clear error.
+  throw new Error(
+    `Browser channel (${sourceType}) requires Claude Code with the agent-browser skill.\n` +
+    `Install: npx skills add vercel-labs/agent-browser\n` +
+    `Then run vp-intake from Claude Code.`
+  );
+}
+
+/**
+ * Check whether a URL appears to be a publicly accessible intake source.
+ * Does not make network requests — pattern-match only.
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isKnownPublicSource(url) {
+  return detectUrlType(url) !== 'generic-table';
+}
+
+module.exports = { readBrowserUrl, detectUrlType, isKnownPublicSource, URL_PATTERNS };

package/lib/intake/adapters/excel-m365.cjs

@@ -186,7 +186,7 @@ async function readViaGraphApi(channel, projectRoot) {
   const response = await httpsGet(url, { Authorization: `Bearer ${token}` });
 
   if (!response.values || response.values.length === 0) return [];
-  return parseRowsWithColumnMap(response.values, channel.column_map);
+  return parseRowsWithColumnMap(response.values, channel.column_map, channel.id);
 }
 
 // ─── SharePoint sharing link (anonymous WOPI) ─────────────────────────────────
@@ -291,18 +291,64 @@ async function readViaSharingLink(channel) {
   const rows = parseXlsxBuffer(xlsxBuffer, channel.sheet_name || null);
 
   if (!rows || rows.length === 0) return [];
-  return parseRowsWithColumnMap(rows, channel.column_map);
+  return parseRowsWithColumnMap(rows, channel.column_map, channel.id);
+}
+
+// ─── Vietnamese/English header → field name auto-detection ────────────────────
+
+const HEADER_ALIASES = {
+  id:          ['stt', 'id', 'no', '#', 'mã', 'ma'],
+  title:       ['title', 'tiêu đề', 'tieu de', 'tên', 'ten', 'màn hình', 'man hinh', 'tên module', 'tên testcase', 'summary'],
+  description: ['mô tả lỗi', 'mo ta loi', 'description', 'mô tả', 'mo ta', 'chi tiết', 'chi tiet', 'detail', 'nội dung', 'noi dung'],
+  status:      ['status', 'trạng thái', 'trang thai', 'kết quả', 'ket qua', 'result', 'p/f/n'],
+  reporter:    ['reporter', 'người báo', 'nguoi bao', 'tester', 'người tạo', 'nguoi tao'],
+  priority:    ['priority', 'mức độ', 'muc do', 'độ ưu tiên', 'severity'],
+};
+
+function autoDetectColumnMap(headerRow) {
+  const map = {};
+  headerRow.forEach((cell, idx) => {
+    const normalized = String(cell).toLowerCase().trim();
+    if (!normalized) return;
+    for (const [field, aliases] of Object.entries(HEADER_ALIASES)) {
+      if (!map[field] && aliases.some(a => normalized.includes(a))) {
+        // Convert 0-based index to Excel letter (A=0, B=1, ...)
+        let col = '';
+        let n = idx;
+        do { col = String.fromCharCode(65 + (n % 26)) + col; n = Math.floor(n / 26) - 1; } while (n >= 0);
+        map[field] = col;
+      }
+    }
+  });
+  return map;
 }
 
 // ─── Common row → ticket mapper ───────────────────────────────────────────────
 
-function parseRowsWithColumnMap(values, colMap) {
+function parseRowsWithColumnMap(values, colMap, channelId) {
+  // Find first non-empty row to use as auto-detect source if needed
+  const firstNonEmpty = values.find(r => r.some(c => c !== ''));
+
+  // Auto-detect or fall back to raw if still missing
+  const resolvedMap = (colMap && Object.keys(colMap).length > 0)
+    ? colMap
+    : (firstNonEmpty ? autoDetectColumnMap(firstNonEmpty) : {});
+
+  if (!colMap || Object.keys(colMap).length === 0) {
+    process.stderr.write(
+      `[vp-intake] No column_map configured. Auto-detected: ${JSON.stringify(resolvedMap)}. ` +
+      `Header row: ${JSON.stringify(firstNonEmpty || [])}\n`
+    );
+  }
+
   const tickets = [];
+  // Skip header row(s): if auto-detected, skip until first row that has a non-header value
+  const startRow = (colMap && Object.keys(colMap).length > 0) ? 1 : values.findIndex(r => r.some(c => c !== '')) + 1;
 
-  for (let i = 1; i < values.length; i++) {
+  for (let i = startRow; i < values.length; i++) {
     const row = values[i];
     const get = (field) => {
-      const col = colMap[field];
+      const col = resolvedMap[field];
       if (!col) return '';
       const idx = colLetterToIndex(col);
       return row[idx] !== undefined ? String(row[idx]) : '';
@@ -316,7 +362,7 @@ function parseRowsWithColumnMap(values, colMap) {
       date:        get('date'),
       status:      get('status'),
       _source_row: i,
-      _channel_id: channel ? channel.id : undefined,
+      _channel_id: channelId,
     };
 
     if (!ticket.title && !ticket.description) continue;
@@ -362,4 +408,6 @@ module.exports = {
   isSharingLink,
   resolveSharePointDownloadUrl,
   parseXlsxBuffer,
+  autoDetectColumnMap,
+  HEADER_ALIASES,
 };