devvami 1.5.0 → 1.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devvami",
   "description": "DevEx CLI for developers and teams — manage repos, PRs, pipelines, tasks, and costs from the terminal",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "author": "",
   "type": "module",
   "bin": {

package/src/commands/sync-config-ai/index.js

@@ -1,7 +1,7 @@
 import {Command, Flags} from '@oclif/core'
 import ora from 'ora'
 
-import {scanEnvironments, computeCategoryCounts} from '../../services/ai-env-scanner.js'
+import {scanEnvironments, computeCategoryCounts, parseNativeEntries, detectDrift, ENVIRONMENTS} from '../../services/ai-env-scanner.js'
 import {
   loadAIConfig,
   addEntry,
@@ -9,14 +9,57 @@ import {
   deactivateEntry,
   activateEntry,
   deleteEntry,
+  syncAIConfigToChezmoi,
 } from '../../services/ai-config-store.js'
 import {deployEntry, undeployEntry, reconcileOnScan} from '../../services/ai-env-deployer.js'
 import {loadConfig} from '../../services/config.js'
-import {formatEnvironmentsTable, formatCategoriesTable} from '../../formatters/ai-config.js'
+import {formatEnvironmentsTable, formatCategoriesTable, formatNativeEntriesTable} from '../../formatters/ai-config.js'
 import {startTabTUI} from '../../utils/tui/tab-tui.js'
 import {DvmiError} from '../../utils/errors.js'
 
-/** @import { DetectedEnvironment, CategoryEntry } from '../../types.js' */
+/** @import { DetectedEnvironment, CategoryEntry, MCPParams } from '../../types.js' */
+
+/**
+ * Extract only MCPParams-relevant fields from raw form values.
+ * Parses args (editor newline-joined) into string[] and env vars (KEY=VALUE lines) into Record.
+ * @param {Record<string, unknown>} values - Raw form output from extractValues
+ * @returns {MCPParams}
+ */
+function buildMCPParams(values) {
+  /** @type {MCPParams} */
+  const params = {transport: /** @type {'stdio'|'sse'|'streamable-http'} */ (values.transport)}
+
+  if (params.transport === 'stdio') {
+    if (values.command) params.command = /** @type {string} */ (values.command)
+    // Args: editor field → newline-joined string → split into array
+    if (values.args && typeof values.args === 'string') {
+      const arr = /** @type {string} */ (values.args).split('\n').map((a) => a.trim()).filter(Boolean)
+      if (arr.length > 0) params.args = arr
+    } else if (Array.isArray(values.args) && values.args.length > 0) {
+      params.args = values.args
+    }
+  } else {
+    if (values.url) params.url = /** @type {string} */ (values.url)
+  }
+
+  // Env vars: editor field → newline-joined KEY=VALUE string → parse into Record.
+  // Env vars apply to ALL transports (e.g. API keys for remote servers too).
+  if (values.env && typeof values.env === 'string') {
+    /** @type {Record<string, string>} */
+    const envObj = {}
+    for (const line of /** @type {string} */ (values.env).split('\n')) {
+      const t = line.trim()
+      if (!t) continue
+      const eq = t.indexOf('=')
+      if (eq > 0) envObj[t.slice(0, eq)] = t.slice(eq + 1)
+    }
+    if (Object.keys(envObj).length > 0) params.env = envObj
+  } else if (values.env && typeof values.env === 'object' && !Array.isArray(values.env)) {
+    params.env = /** @type {Record<string, string>} */ (values.env)
+  }
+
+  return params
+}
 
 export default class SyncConfigAi extends Command {
   static description = 'Manage AI coding tool configurations across environments via TUI'
@@ -75,17 +118,57 @@ export default class SyncConfigAi extends Command {
       env.counts = computeCategoryCounts(env.id, store.entries)
     }
 
+    // ── Parse native entries and populate nativeCounts ───────────────────────
+    const envDefMap = new Map(ENVIRONMENTS.map((e) => [e.id, e]))
+    for (const env of detectedEnvs) {
+      const envDef = envDefMap.get(env.id)
+      if (!envDef) continue
+      const natives = parseNativeEntries(envDef, process.cwd(), store.entries)
+      env.nativeEntries = natives
+      // Aggregate native counts per category
+      env.nativeCounts = {mcp: 0, command: 0, rule: 0, skill: 0, agent: 0}
+      for (const ne of natives) {
+        env.nativeCounts[ne.type] = (env.nativeCounts[ne.type] ?? 0) + 1
+      }
+    }
+
+    // ── Detect drift for managed entries ────────────────────────────────────
+    const driftInfos = detectDrift(detectedEnvs, store.entries, process.cwd())
+    for (const env of detectedEnvs) {
+      env.driftedEntries = driftInfos.filter((d) => d.environmentId === env.id)
+    }
+
     spinner?.stop()
 
     // ── JSON mode ────────────────────────────────────────────────────────────
     if (isJson) {
+      if (detectedEnvs.length === 0) {
+        this.exit(2)
+      }
+
+      // Collect all native entries grouped by type
+      const allNatives = detectedEnvs.flatMap((e) => e.nativeEntries ?? [])
+
+      // Build drifted set for quick lookup
+      const driftedIds = new Set(driftInfos.map((d) => d.entryId))
+
       const categories = {
-        mcp: store.entries.filter((e) => e.type === 'mcp'),
-        command: store.entries.filter((e) => e.type === 'command'),
-        skill: store.entries.filter((e) => e.type === 'skill'),
-        agent: store.entries.filter((e) => e.type === 'agent'),
+        mcp: store.entries.filter((e) => e.type === 'mcp').map((e) => ({...e, drifted: driftedIds.has(e.id)})),
+        command: store.entries.filter((e) => e.type === 'command').map((e) => ({...e, drifted: driftedIds.has(e.id)})),
+        rule: store.entries.filter((e) => e.type === 'rule').map((e) => ({...e, drifted: driftedIds.has(e.id)})),
+        skill: store.entries.filter((e) => e.type === 'skill').map((e) => ({...e, drifted: driftedIds.has(e.id)})),
+        agent: store.entries.filter((e) => e.type === 'agent').map((e) => ({...e, drifted: driftedIds.has(e.id)})),
       }
-      return {environments: detectedEnvs, categories}
+
+      const nativeEntries = {
+        mcp: allNatives.filter((e) => e.type === 'mcp'),
+        command: allNatives.filter((e) => e.type === 'command'),
+        rule: allNatives.filter((e) => e.type === 'rule'),
+        skill: allNatives.filter((e) => e.type === 'skill'),
+        agent: allNatives.filter((e) => e.type === 'agent'),
+      }
+
+      return {environments: detectedEnvs, categories, nativeEntries}
     }
 
     // ── Check chezmoi config ─────────────────────────────────────────────────
@@ -104,6 +187,7 @@ export default class SyncConfigAi extends Command {
       chezmoiEnabled,
       formatEnvs: formatEnvironmentsTable,
       formatCats: formatCategoriesTable,
+      formatNative: formatNativeEntriesTable,
       refreshEntries: async () => {
         const s = await loadAIConfig()
         return s.entries
@@ -113,16 +197,21 @@ export default class SyncConfigAi extends Command {
         const currentStore = await loadAIConfig()
 
         if (action.type === 'create') {
+          const isMCP = action.tabKey === 'mcp'
           const created = await addEntry({
             name: action.values.name,
             type: action.tabKey || 'mcp',
             environments: action.values.environments || [],
-            params: action.values,
+            params: isMCP ? buildMCPParams(action.values) : action.values,
           })
           await deployEntry(created, detectedEnvs, process.cwd())
+          await syncAIConfigToChezmoi()
         } else if (action.type === 'edit') {
-          const updated = await updateEntry(action.id, {params: action.values})
+          const entry = currentStore.entries.find((e) => e.id === action.id)
+          const isMCP = entry?.type === 'mcp'
+          const updated = await updateEntry(action.id, {params: isMCP ? buildMCPParams(action.values) : action.values})
           await deployEntry(updated, detectedEnvs, process.cwd())
+          await syncAIConfigToChezmoi()
         } else if (action.type === 'delete') {
           await deleteEntry(action.id)
           await undeployEntry(
@@ -130,12 +219,37 @@ export default class SyncConfigAi extends Command {
             detectedEnvs,
             process.cwd(),
           )
+          await syncAIConfigToChezmoi()
         } else if (action.type === 'deactivate') {
           const entry = await deactivateEntry(action.id)
           await undeployEntry(entry, detectedEnvs, process.cwd())
+          await syncAIConfigToChezmoi()
         } else if (action.type === 'activate') {
           const entry = await activateEntry(action.id)
           await deployEntry(entry, detectedEnvs, process.cwd())
+          await syncAIConfigToChezmoi()
+        } else if (action.type === 'import-native') {
+          // T017: Import native entry into dvmi-managed sync
+          const ne = action.nativeEntry
+          const created = await addEntry({
+            name: ne.name,
+            type: ne.type,
+            environments: [ne.environmentId],
+            params: ne.params,
+          })
+          await deployEntry(created, detectedEnvs, process.cwd())
+          await syncAIConfigToChezmoi()
+        } else if (action.type === 'redeploy') {
+          // T018: Re-deploy managed entry to overwrite drifted file
+          const entry = currentStore.entries.find((e) => e.id === action.id)
+          if (entry) await deployEntry(entry, detectedEnvs, process.cwd())
+        } else if (action.type === 'accept-drift') {
+          // T018: Accept drift — update store params from the actual file state
+          const drift = driftInfos.find((d) => d.entryId === action.id)
+          if (drift) {
+            await updateEntry(action.id, {params: drift.actual})
+            await syncAIConfigToChezmoi()
+          }
         }
       },
     })

package/src/formatters/ai-config.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk'
 
-/** @import { DetectedEnvironment, CategoryEntry } from '../types.js' */
+/** @import { DetectedEnvironment, CategoryEntry, NativeEntry } from '../types.js' */
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Internal helpers
@@ -41,11 +41,12 @@ export function formatEnvironmentsTable(detectedEnvs, termCols = 120) {
     chalk.bold.white(padCell('Scope', COL_SCOPE)),
     chalk.bold.white(padCell('MCPs', COL_COUNT)),
     chalk.bold.white(padCell('Commands', COL_COUNT)),
+    chalk.bold.white(padCell('Rules', COL_COUNT)),
     chalk.bold.white(padCell('Skills', COL_COUNT)),
     chalk.bold.white(padCell('Agents', COL_COUNT)),
   ]
 
-  const dividerWidth = COL_ENV + COL_STATUS + COL_SCOPE + COL_COUNT * 4 + 6 * 2
+  const dividerWidth = COL_ENV + COL_STATUS + COL_SCOPE + COL_COUNT * 5 + 7 * 2
   const lines = []
   lines.push(headerParts.join('  '))
   lines.push(chalk.dim('─'.repeat(Math.min(termCols, dividerWidth))))
@@ -58,34 +59,119 @@ export function formatEnvironmentsTable(detectedEnvs, termCols = 120) {
       : chalk.green(padCell(statusText, COL_STATUS))
     const scopeStr = padCell(env.scope ?? 'project', COL_SCOPE)
 
-    const mcpStr = padCell(String(env.counts.mcp), COL_COUNT)
-    const cmdStr = padCell(String(env.counts.command), COL_COUNT)
+    const total = (/** @type {string} */ type) => (env.counts?.[type] ?? 0) + (env.nativeCounts?.[type] ?? 0)
+    const mcpStr = padCell(String(total('mcp')), COL_COUNT)
+    const cmdStr = padCell(String(total('command')), COL_COUNT)
+    const ruleStr = env.supportedCategories.includes('rule')
+      ? padCell(String(total('rule')), COL_COUNT)
+      : padCell('—', COL_COUNT)
     const skillStr = env.supportedCategories.includes('skill')
-      ? padCell(String(env.counts.skill), COL_COUNT)
+      ? padCell(String(total('skill')), COL_COUNT)
       : padCell('—', COL_COUNT)
     const agentStr = env.supportedCategories.includes('agent')
-      ? padCell(String(env.counts.agent), COL_COUNT)
+      ? padCell(String(total('agent')), COL_COUNT)
       : padCell('—', COL_COUNT)
 
-    lines.push([padCell(env.name, COL_ENV), statusStr, scopeStr, mcpStr, cmdStr, skillStr, agentStr].join('  '))
+    lines.push([padCell(env.name, COL_ENV), statusStr, scopeStr, mcpStr, cmdStr, ruleStr, skillStr, agentStr].join('  '))
   }
 
   return lines
 }
 
-// ──────────────────────────────────────────────────────────────────────────────
-// Categories table formatter
-// ──────────────────────────────────────────────────────────────────────────────
-
 /** @type {Record<string, string>} */
 const ENV_SHORT_NAMES = {
   'vscode-copilot': 'VSCode',
   'claude-code': 'Claude',
+  'claude-desktop': 'Desktop',
   opencode: 'OpenCode',
   'gemini-cli': 'Gemini',
   'copilot-cli': 'Copilot',
+  cursor: 'Cursor',
+  windsurf: 'Windsurf',
+  'continue-dev': 'Continue',
+  zed: 'Zed',
+  'amazon-q': 'Amazon Q',
+}
+
+/**
+ * Mask an environment variable value for display.
+ * Shows first 6 characters followed by ***.
+ * @param {string} value
+ * @returns {string}
+ */
+export function maskEnvVarValue(value) {
+  if (!value || value.length <= 6) return '***'
+  return value.slice(0, 6) + '***'
 }
 
+// ──────────────────────────────────────────────────────────────────────────────
+// Native entries table formatter
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Format native entries as a table for display in a category tab's Native section.
+ * @param {NativeEntry[]} entries
+ * @param {number} [termCols]
+ * @returns {string[]}
+ */
+export function formatNativeEntriesTable(entries, termCols = 120) {
+  const COL_NAME = 24
+  const COL_ENV = 16
+  const COL_LEVEL = 8
+  const COL_CONFIG = 36
+
+  const headerParts = [
+    chalk.bold.white(padCell('Name', COL_NAME)),
+    chalk.bold.white(padCell('Environment', COL_ENV)),
+    chalk.bold.white(padCell('Level', COL_LEVEL)),
+    chalk.bold.white(padCell('Config', COL_CONFIG)),
+  ]
+
+  const dividerWidth = COL_NAME + COL_ENV + COL_LEVEL + COL_CONFIG + 3 * 2
+  const lines = []
+  lines.push(headerParts.join('  '))
+  lines.push(chalk.dim('─'.repeat(Math.min(termCols, dividerWidth))))
+
+  for (const entry of entries) {
+    const envShort = ENV_SHORT_NAMES[entry.environmentId] ?? entry.environmentId
+    const levelStr = padCell(entry.level, COL_LEVEL)
+
+    // Build config summary
+    const params = /** @type {any} */ (entry.params ?? {})
+    let configSummary = ''
+    if (entry.type === 'mcp') {
+      if (params.command) {
+        const args = Array.isArray(params.args) ? params.args.slice(0, 2).join(' ') : ''
+        configSummary = [params.command, args].filter(Boolean).join(' ')
+      } else if (params.url) {
+        configSummary = params.url
+      }
+      // Mask env vars
+      if (params.env && Object.keys(params.env).length > 0) {
+        const maskedVars = Object.keys(params.env)
+          .map((k) => `${k}=${maskEnvVarValue(params.env[k])}`)
+          .join(', ')
+        configSummary = configSummary ? `${configSummary} [${maskedVars}]` : maskedVars
+      }
+    } else {
+      configSummary = params.description ?? params.content?.slice(0, 30) ?? ''
+    }
+
+    lines.push([
+      padCell(entry.name, COL_NAME),
+      padCell(envShort, COL_ENV),
+      levelStr,
+      padCell(configSummary, COL_CONFIG),
+    ].join('  '))
+  }
+
+  return lines
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Categories table formatter
+// ──────────────────────────────────────────────────────────────────────────────
+
 /**
  * Format a list of category entries as a table string for display in the TUI.
  * Columns: Name, Type, Status, Environments
@@ -113,7 +199,9 @@ export function formatCategoriesTable(entries, termCols = 120) {
 
   for (const entry of entries) {
     const statusStr = entry.active
-      ? chalk.green(padCell('Active', COL_STATUS))
+      ? (/** @type {any} */ (entry)).drifted
+        ? chalk.yellow(padCell('⚠ Drifted', COL_STATUS))
+        : chalk.green(padCell('Active', COL_STATUS))
       : chalk.dim(padCell('Inactive', COL_STATUS))
 
     const envNames = entry.environments.map((id) => ENV_SHORT_NAMES[id] ?? id).join(', ')

package/src/services/ai-config-store.js

@@ -8,7 +8,7 @@ import {DvmiError} from '../utils/errors.js'
 import {exec} from './shell.js'
 import {loadConfig} from './config.js'
 
-/** @import { AIConfigStore, CategoryEntry, CategoryType, EnvironmentId, MCPParams, CommandParams, SkillParams, AgentParams } from '../types.js' */
+/** @import { AIConfigStore, CategoryEntry, CategoryType, EnvironmentId, MCPParams, CommandParams, RuleParams, SkillParams, AgentParams } from '../types.js' */
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Path resolution
@@ -26,11 +26,17 @@ export const AI_CONFIG_PATH = join(CONFIG_DIR, 'ai-config.json')
 
 /** @type {Record<EnvironmentId, CategoryType[]>} */
 const COMPATIBILITY = {
-  'vscode-copilot': ['mcp', 'command', 'skill', 'agent'],
-  'claude-code': ['mcp', 'command', 'skill', 'agent'],
-  opencode: ['mcp', 'command', 'skill', 'agent'],
-  'gemini-cli': ['mcp', 'command'],
-  'copilot-cli': ['mcp', 'command', 'skill', 'agent'],
+  'vscode-copilot': ['mcp', 'command', 'rule', 'skill', 'agent'],
+  'claude-code': ['mcp', 'command', 'rule', 'skill', 'agent'],
+  'claude-desktop': ['mcp'],
+  opencode: ['mcp', 'command', 'rule', 'skill', 'agent'],
+  'gemini-cli': ['mcp', 'command', 'rule'],
+  'copilot-cli': ['mcp', 'command', 'rule', 'skill', 'agent'],
+  cursor: ['mcp', 'command', 'rule', 'skill'],
+  windsurf: ['mcp', 'command', 'rule'],
+  'continue-dev': ['mcp', 'command', 'rule', 'agent'],
+  zed: ['mcp', 'rule'],
+  'amazon-q': ['mcp', 'rule', 'agent'],
 }
 
 /** All known environment IDs. */
@@ -45,7 +51,20 @@ const UNSAFE_CHARS = /[/\\:*?"<>|]/
 
 /** @returns {AIConfigStore} */
 function defaultStore() {
-  return {version: 1, entries: []}
+  return {version: 2, entries: []}
+}
+
+/**
+ * Migrate an AI config store to the current schema version.
+ * v1 → v2 is a no-op data migration; it only bumps the version field.
+ * @param {AIConfigStore} store
+ * @returns {AIConfigStore}
+ */
+function migrateStore(store) {
+  if (store.version === 1) {
+    return {...store, version: 2}
+  }
+  return store
 }
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -93,6 +112,20 @@ function validateEnvironments(environments, type) {
   }
 }
 
+/**
+ * Assert that rule params contain a non-empty string `content` field.
+ * @param {RuleParams} params
+ * @returns {void}
+ */
+function validateRuleParams(params) {
+  if (!params || typeof params.content !== 'string' || params.content.trim() === '') {
+    throw new DvmiError(
+      'Rule entry requires a non-empty "content" string',
+      'Provide the rule content, e.g. { content: "Always use TypeScript" }',
+    )
+  }
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Core I/O
 // ──────────────────────────────────────────────────────────────────────────────
@@ -108,10 +141,7 @@ export async function loadAIConfig(configPath = process.env.DVMI_AI_CONFIG_PATH
   try {
     const raw = await readFile(configPath, 'utf8')
     const parsed = JSON.parse(raw)
-    return {
-      version: parsed.version ?? 1,
-      entries: Array.isArray(parsed.entries) ? parsed.entries : [],
-    }
+    return migrateStore({version: parsed.version ?? 1, entries: Array.isArray(parsed.entries) ? parsed.entries : []})
   } catch {
     return defaultStore()
   }
@@ -139,7 +169,7 @@ export async function saveAIConfig(store, configPath = process.env.DVMI_AI_CONFI
 
 /**
  * Add a new entry to the AI config store.
- * @param {{ name: string, type: CategoryType, environments: EnvironmentId[], params: MCPParams|CommandParams|SkillParams|AgentParams }} entryData
+ * @param {{ name: string, type: CategoryType, environments: EnvironmentId[], params: MCPParams|CommandParams|RuleParams|SkillParams|AgentParams }} entryData
  * @param {string} [configPath]
  * @returns {Promise<CategoryEntry>}
  */
@@ -148,6 +178,7 @@ export async function addEntry(entryData, configPath = process.env.DVMI_AI_CONFI
 
   validateName(name)
   validateEnvironments(environments, type)
+  if (type === 'rule') validateRuleParams(/** @type {RuleParams} */ (params))
 
   const store = await loadAIConfig(configPath)