@syntesseraai/opencode-feature-factory 0.6.7 → 0.6.8

package/bin/ff-deploy.js

@@ -51,6 +51,40 @@ const DEFAULT_MCP_SERVERS = {
   },
 };
 
+const DEFAULT_PLUGINS = [
+  '@syntesseraai/opencode-feature-factory@latest',
+  '@nick-vi/opencode-type-inject@latest',
+  '@franlol/opencode-md-table-formatter@latest',
+  '@spoons-and-mirrors/subtask2@latest',
+  'opencode-pty@latest',
+  '@angdrew/opencode-hashline-plugin@latest',
+];
+
+function getPackageBaseName(plugin) {
+  if (plugin.startsWith('@')) {
+    const slashIndex = plugin.indexOf('/');
+    if (slashIndex !== -1) {
+      const versionAt = plugin.indexOf('@', slashIndex + 1);
+      if (versionAt !== -1) {
+        return plugin.substring(0, versionAt);
+      }
+    }
+    return plugin;
+  }
+
+  const atIndex = plugin.indexOf('@');
+  if (atIndex !== -1) {
+    return plugin.substring(0, atIndex);
+  }
+
+  return plugin;
+}
+
+function hasPlugin(existing, plugin) {
+  const baseName = getPackageBaseName(plugin);
+  return existing.some((entry) => getPackageBaseName(entry) === baseName);
+}
+
 async function ensureDir(dir) {
   try {
     await fs.mkdir(dir, { recursive: true });
@@ -127,11 +161,30 @@ async function updateMCPConfig() {
   try {
     // Read existing config if it exists
     let existingConfig = {};
+    let hasExistingConfigFile = false;
     try {
       const configContent = await fs.readFile(GLOBAL_CONFIG_FILE, 'utf8');
+      hasExistingConfigFile = true;
       existingConfig = JSON.parse(configContent);
-    } catch {
-      // No existing config, will create new
+      if (!existingConfig || typeof existingConfig !== 'object' || Array.isArray(existingConfig)) {
+        if (isInteractive) {
+          console.warn('\n⚠️  Existing opencode.json is not a JSON object. Skipping update.');
+        }
+        return;
+      }
+    } catch (error) {
+      if (error && error.code === 'ENOENT') {
+        // No existing config, will create new
+      } else if (error instanceof SyntaxError) {
+        if (isInteractive) {
+          console.warn(
+            '\n⚠️  Existing opencode.json is invalid JSON. Skipping update to avoid overwriting user config.'
+          );
+        }
+        return;
+      } else {
+        throw error;
+      }
     }
 
     // Check which MCP servers need to be added
@@ -157,15 +210,33 @@ async function updateMCPConfig() {
       }
     }
 
-    if (serversAdded === 0) {
+    const existingPlugins = Array.isArray(existingConfig.plugin)
+      ? existingConfig.plugin.filter((entry) => typeof entry === 'string')
+      : [];
+    const pluginsToAdd = [];
+
+    for (const plugin of DEFAULT_PLUGINS) {
+      if (hasPlugin(existingPlugins, plugin)) {
+        if (isInteractive) {
+          console.log(`  ⏭️  ${plugin}: already exists, skipping`);
+        }
+      } else {
+        pluginsToAdd.push(plugin);
+        if (isInteractive) {
+          console.log(`  ✅ ${plugin}: will be added`);
+        }
+      }
+    }
+
+    if (serversAdded === 0 && pluginsToAdd.length === 0) {
       if (isInteractive) {
-        console.log('\n✅ All MCP servers already configured. No changes needed.');
+        console.log('\n✅ Required MCP servers and plugins already configured. No changes needed.');
       }
       return;
     }
 
     // Backup existing config if it exists
-    if (existingConfig && Object.keys(existingConfig).length > 0) {
+    if (hasExistingConfigFile && existingConfig && Object.keys(existingConfig).length > 0) {
       const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
       const backupFile = `${GLOBAL_CONFIG_FILE}.backup.${timestamp}`;
       await fs.writeFile(backupFile, JSON.stringify(existingConfig, null, 2));
@@ -181,6 +252,7 @@ async function updateMCPConfig() {
         ...existingMcp,
         ...serversToAdd,
       },
+      plugin: [...existingPlugins, ...pluginsToAdd],
     };
 
     // Write updated config
@@ -188,11 +260,13 @@ async function updateMCPConfig() {
     await fs.writeFile(GLOBAL_CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
 
     if (isInteractive) {
-      console.log(`\n✅ Added ${serversAdded} MCP server(s) to: ${GLOBAL_CONFIG_FILE}`);
+      console.log(`\n✅ Updated OpenCode config: ${GLOBAL_CONFIG_FILE}`);
+      console.log(`   Added ${serversAdded} MCP server(s)`);
+      console.log(`   Added ${pluginsToAdd.length} plugin(s)`);
       if (serversSkipped > 0) {
         console.log(`   Skipped ${serversSkipped} existing server(s)`);
       }
-      console.log('\n📝 Note: Restart OpenCode to load new MCP configuration');
+      console.log('\n📝 Note: Restart OpenCode to load new configuration');
     }
   } catch (error) {
     if (isInteractive) {

package/dist/agent-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
-const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
+import { isRecord, updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Built-in opencode agents that should be disabled when the Feature Factory
  * plugin is active. These are the standard opencode agents that overlap with
@@ -42,50 +38,20 @@ export function mergeAgentConfigs(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updateAgentConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing agent configs from global config
-    const existingAgentConfigs = (globalJson?.agent ?? {});
-    // Merge with default agent configs
-    const updatedAgentConfigs = mergeAgentConfigs(existingAgentConfigs, DEFAULT_DISABLED_AGENTS);
-    // Check if any changes are needed
-    const hasChanges = Object.keys(DEFAULT_DISABLED_AGENTS).some((agentName) => !existingAgentConfigs[agentName]);
-    if (!hasChanges) {
-        // All default agent configs already exist, no need to update
-        return;
-    }
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        agent: updatedAgentConfigs,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update agent config:', error);
-    }
+    void $;
+    await updateGlobalOpenCodeConfigBlock({
+        blockName: 'agent',
+        warningLabel: 'agent config',
+        update: (existingBlock) => {
+            const existingAgentConfigs = isRecord(existingBlock)
+                ? existingBlock
+                : undefined;
+            const updatedAgentConfigs = mergeAgentConfigs(existingAgentConfigs, DEFAULT_DISABLED_AGENTS);
+            const hasChanges = Object.keys(DEFAULT_DISABLED_AGENTS).some((agentName) => !existingAgentConfigs?.[agentName]);
+            return {
+                nextBlock: updatedAgentConfigs,
+                changed: hasChanges,
+            };
+        },
+    });
 }

package/dist/mcp-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
-const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
+import { isRecord, updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Default MCP server configuration to be added by the plugin
  * These servers will be merged into the global OpenCode config.
@@ -54,50 +50,20 @@ export function mergeMCPServers(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updateMCPConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing MCP servers from global config
-    const existingMcpServers = (globalJson?.mcp ?? {});
-    // Merge with default MCP servers
-    const updatedMcpServers = mergeMCPServers(existingMcpServers, DEFAULT_MCP_SERVERS);
-    // Check if any changes are needed
-    const hasChanges = Object.keys(DEFAULT_MCP_SERVERS).some((serverName) => !existingMcpServers[serverName]);
-    if (!hasChanges) {
-        // All default servers already exist, no need to update
-        return;
-    }
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        mcp: updatedMcpServers,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update MCP config:', error);
-    }
+    void $;
+    await updateGlobalOpenCodeConfigBlock({
+        blockName: 'mcp',
+        warningLabel: 'MCP config',
+        update: (existingBlock) => {
+            const existingMcpServers = isRecord(existingBlock)
+                ? existingBlock
+                : undefined;
+            const updatedMcpServers = mergeMCPServers(existingMcpServers, DEFAULT_MCP_SERVERS);
+            const hasChanges = Object.keys(DEFAULT_MCP_SERVERS).some((serverName) => !existingMcpServers?.[serverName]);
+            return {
+                nextBlock: updatedMcpServers,
+                changed: hasChanges,
+            };
+        },
+    });
 }

package/dist/opencode-global-config.d.ts

@@ -0,0 +1,9 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function updateGlobalOpenCodeConfigBlock<T>(options: {
+    blockName: string;
+    warningLabel: string;
+    update: (existingBlock: unknown) => {
+        nextBlock: T;
+        changed: boolean;
+    };
+}): Promise<void>;

package/dist/opencode-global-config.js

@@ -0,0 +1,79 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
+const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function loadGlobalOpenCodeConfig() {
+    try {
+        const configContent = await readFile(GLOBAL_OPENCODE_CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(configContent);
+        if (!isRecord(parsed)) {
+            return {
+                config: {},
+                hasExistingFile: true,
+                parseError: true,
+            };
+        }
+        return {
+            config: parsed,
+            hasExistingFile: true,
+            parseError: false,
+        };
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return {
+                config: {},
+                hasExistingFile: false,
+                parseError: false,
+            };
+        }
+        if (error instanceof SyntaxError) {
+            return {
+                config: {},
+                hasExistingFile: true,
+                parseError: true,
+            };
+        }
+        throw error;
+    }
+}
+export async function updateGlobalOpenCodeConfigBlock(options) {
+    const { blockName, warningLabel, update } = options;
+    const loaded = await loadGlobalOpenCodeConfig();
+    if (loaded.parseError) {
+        console.warn(`[feature-factory] Could not update ${warningLabel}: existing opencode.json is not valid JSON`);
+        return;
+    }
+    const { nextBlock, changed } = update(loaded.config[blockName]);
+    if (!changed) {
+        return;
+    }
+    const updatedConfig = {
+        ...loaded.config,
+        [blockName]: nextBlock,
+    };
+    await mkdir(GLOBAL_OPENCODE_DIR, { recursive: true });
+    if (loaded.hasExistingFile && Object.keys(loaded.config).length > 0) {
+        try {
+            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
+            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
+            await writeFile(backupPath, JSON.stringify(loaded.config, null, 2));
+        }
+        catch (error) {
+            console.warn('[feature-factory] Could not create backup:', error);
+        }
+    }
+    try {
+        await writeFile(GLOBAL_OPENCODE_CONFIG_PATH, JSON.stringify(updatedConfig, null, 2));
+    }
+    catch (error) {
+        console.warn(`[feature-factory] Could not update ${warningLabel}:`, error);
+    }
+}

package/dist/plugin-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
-const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
+import { updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Default plugins that should be present in the global OpenCode config.
  * These will be merged into the existing plugin array without removing
@@ -88,53 +84,20 @@ export function mergePlugins(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updatePluginConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing plugins from global config
-    const existingPlugins = Array.isArray(globalJson?.plugin)
-        ? globalJson.plugin
-        : undefined;
-    // Check if any changes are needed (by base name)
-    const existingArray = existingPlugins ?? [];
-    const hasChanges = DEFAULT_PLUGINS.some((plugin) => !hasPlugin(existingArray, plugin));
-    if (!hasChanges) {
-        // All default plugins already present (possibly with pinned versions)
-        return;
-    }
-    // Merge with default plugins
-    const updatedPlugins = mergePlugins(existingPlugins, DEFAULT_PLUGINS);
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        plugin: updatedPlugins,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update plugin config:', error);
-    }
+    void $;
+    await updateGlobalOpenCodeConfigBlock({
+        blockName: 'plugin',
+        warningLabel: 'plugin config',
+        update: (existingBlock) => {
+            const existingPlugins = Array.isArray(existingBlock)
+                ? existingBlock.filter((entry) => typeof entry === 'string')
+                : undefined;
+            const existingArray = existingPlugins ?? [];
+            const hasChanges = DEFAULT_PLUGINS.some((plugin) => !hasPlugin(existingArray, plugin));
+            return {
+                nextBlock: mergePlugins(existingPlugins, DEFAULT_PLUGINS),
+                changed: hasChanges,
+            };
+        },
+    });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",