@link-assistant/agent 0.2.0 → 0.3.0

package/EXAMPLES.md

@@ -211,7 +211,7 @@ echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"Re
 **opencode (requires OPENCODE_EXPERIMENTAL_EXA=true):**
 
 ```bash
-echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"TypeScript latest features"}}]}' | OPENCODE_EXPERIMENTAL_EXA=true opencode run --format json --model opencode/grok-code
+echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"TypeScript latest features"}}]}' | opencode run --format json --model opencode/grok-code
 ```
 
 ### codesearch Tool
@@ -229,7 +229,7 @@ echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"
 **opencode (requires OPENCODE_EXPERIMENTAL_EXA=true):**
 
 ```bash
-echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"React hooks implementation"}}]}' | OPENCODE_EXPERIMENTAL_EXA=true opencode run --format json --model opencode/grok-code
+echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"React hooks implementation"}}]}' | opencode run --format json --model opencode/grok-code
 ```
 
 ## Execution Tools
@@ -248,8 +248,8 @@ echo '{"message":"run batch","tools":[{"name":"batch","params":{"tool_calls":[{"
 
 ```bash
 # Create config file first
-mkdir -p .opencode
-echo '{"experimental":{"batch_tool":true}}' > .opencode/config.json
+mkdir -p .link-assistant-agent
+echo '{"experimental":{"batch_tool":true}}' > .link-assistant-agent/opencode.json
 
 # Then run
 echo '{"message":"run batch","tools":[{"name":"batch","params":{"tool_calls":[{"tool":"bash","parameters":{"command":"echo hello"}},{"tool":"bash","parameters":{"command":"echo world"}}]}}]}' | opencode run --format json --model opencode/grok-code

package/README.md

@@ -314,7 +314,7 @@ agent mcp add playwright npx @playwright/mcp@latest
 agent mcp list
 ```
 
-This will create a configuration file at `~/.config/opencode/opencode.json` (or your system's config directory) with:
+This will create a configuration file at `~/.config/link-assistant-agent/opencode.json` (or your system's config directory) with:
 
 ```json
 {
@@ -477,7 +477,7 @@ The package publishes source files directly (no build step required). Bun handle
 
 ### No Configuration Required
 
-- **WebSearch/CodeSearch**: Work without `OPENCODE_EXPERIMENTAL_EXA` environment variable
+- **WebSearch/CodeSearch**: Work without `LINK_ASSISTANT_AGENT_EXPERIMENTAL_EXA` environment variable (legacy `OPENCODE_EXPERIMENTAL_EXA` still supported)
 - **Batch Tool**: Always enabled, no experimental flag needed
 - **All Tools**: No config files, API keys handled automatically
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/bun/index.ts

@@ -4,6 +4,7 @@ import { Log } from '../util/log';
 import path from 'path';
 import { NamedError } from '../util/error';
 import { readableStreamToText } from 'bun';
+import { Flag } from '../flag/flag';
 
 export namespace BunProc {
   const log = Log.create({ service: 'bun' });
@@ -43,7 +44,10 @@ export namespace BunProc {
       stderr,
     });
     if (code !== 0) {
-      throw new Error(`Command failed with exit code ${result.exitCode}`);
+      const parts = [`Command failed with exit code ${result.exitCode}`];
+      if (stderr) parts.push(`stderr: ${stderr}`);
+      if (stdout) parts.push(`stdout: ${stdout}`);
+      throw new Error(parts.join('\n'));
     }
     return result;
   }
@@ -57,6 +61,7 @@ export namespace BunProc {
     z.object({
       pkg: z.string(),
       version: z.string(),
+      details: z.string().optional(),
     })
   );
 
@@ -70,6 +75,20 @@ export namespace BunProc {
     });
     if (parsed.dependencies[pkg] === version) return mod;
 
+    // Check for dry-run mode
+    if (Flag.OPENCODE_DRY_RUN) {
+      log.info(
+        '[DRY RUN] Would install package (skipping actual installation)',
+        {
+          pkg,
+          version,
+          targetPath: mod,
+        }
+      );
+      // In dry-run mode, pretend the package is installed
+      return mod;
+    }
+
     // Build command arguments
     const args = [
       'add',
@@ -92,13 +111,20 @@ export namespace BunProc {
     await BunProc.run(args, {
       cwd: Global.Path.cache,
     }).catch((e) => {
+      log.error('package installation failed', {
+        pkg,
+        version,
+        error: e instanceof Error ? e.message : String(e),
+        stack: e instanceof Error ? e.stack : undefined,
+      });
       throw new InstallFailedError(
-        { pkg, version },
+        { pkg, version, details: e instanceof Error ? e.message : String(e) },
         {
           cause: e,
         }
       );
     });
+    log.info('package installed successfully', { pkg, version });
     parsed.dependencies[pkg] = version;
     await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
     return mod;

package/src/config/config.ts

@@ -22,6 +22,103 @@ import { ConfigMarkdown } from './markdown';
 export namespace Config {
   const log = Log.create({ service: 'config' });
 
+  /**
+   * Automatically migrate .opencode directories to .link-assistant-agent
+   * This ensures a smooth transition for both file system configs and environment variables.
+   * Once .link-assistant-agent exists, we stop reading from .opencode.
+   */
+  async function migrateConfigDirectories() {
+    // Find all .opencode and .link-assistant-agent directories in the project hierarchy
+    const allDirs = await Array.fromAsync(
+      Filesystem.up({
+        targets: ['.link-assistant-agent', '.opencode'],
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })
+    );
+
+    const newConfigDirs = allDirs.filter((d) =>
+      d.endsWith('.link-assistant-agent')
+    );
+    const oldConfigDirs = allDirs.filter((d) => d.endsWith('.opencode'));
+
+    // For each old config directory, check if there's a corresponding new one
+    for (const oldDir of oldConfigDirs) {
+      const parentDir = path.dirname(oldDir);
+      const newDir = path.join(parentDir, '.link-assistant-agent');
+
+      // Check if the new directory already exists at the same level
+      const newDirExists = newConfigDirs.includes(newDir);
+
+      if (!newDirExists) {
+        try {
+          // Perform migration by copying the entire directory
+          log.info(
+            `Migrating config from ${oldDir} to ${newDir} for smooth transition`
+          );
+
+          // Use fs-extra style recursive copy
+          await copyDirectory(oldDir, newDir);
+
+          log.info(`Successfully migrated config to ${newDir}`);
+        } catch (error) {
+          log.error(`Failed to migrate config from ${oldDir}:`, error);
+          // Don't throw - allow the app to continue with the old config
+        }
+      }
+    }
+
+    // Also migrate global config if needed
+    const oldGlobalPath = path.join(os.homedir(), '.config', 'opencode');
+    const newGlobalPath = Global.Path.config;
+
+    try {
+      const oldGlobalExists = await fs
+        .stat(oldGlobalPath)
+        .then(() => true)
+        .catch(() => false);
+      const newGlobalExists = await fs
+        .stat(newGlobalPath)
+        .then(() => true)
+        .catch(() => false);
+
+      if (oldGlobalExists && !newGlobalExists) {
+        log.info(
+          `Migrating global config from ${oldGlobalPath} to ${newGlobalPath}`
+        );
+        await copyDirectory(oldGlobalPath, newGlobalPath);
+        log.info(`Successfully migrated global config to ${newGlobalPath}`);
+      }
+    } catch (error) {
+      log.error('Failed to migrate global config:', error);
+      // Don't throw - allow the app to continue
+    }
+  }
+
+  /**
+   * Recursively copy a directory and all its contents
+   */
+  async function copyDirectory(src: string, dest: string) {
+    // Create destination directory
+    await fs.mkdir(dest, { recursive: true });
+
+    // Read all entries in source directory
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively copy subdirectories
+        await copyDirectory(srcPath, destPath);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        // Copy files
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
   export const state = Instance.state(async () => {
     const auth = await Auth.all();
     let result = await global();
@@ -64,20 +161,43 @@ export namespace Config {
     result.agent = result.agent || {};
     result.mode = result.mode || {};
 
-    const directories = [
-      Global.Path.config,
-      ...(await Array.fromAsync(
-        Filesystem.up({
-          targets: ['.opencode'],
-          start: Instance.directory,
-          stop: Instance.worktree,
-        })
-      )),
-    ];
+    // Perform automatic migration from .opencode to .link-assistant-agent if needed
+    await migrateConfigDirectories();
+
+    // Find all config directories
+    const foundDirs = await Array.fromAsync(
+      Filesystem.up({
+        targets: ['.link-assistant-agent', '.opencode'],
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })
+    );
+
+    // Check if any .link-assistant-agent directory exists
+    const hasNewConfig = foundDirs.some((d) =>
+      d.endsWith('.link-assistant-agent')
+    );
+
+    // Filter out .opencode directories if .link-assistant-agent exists
+    const filteredDirs = foundDirs.filter((dir) => {
+      // If .link-assistant-agent exists, exclude .opencode directories
+      if (hasNewConfig && dir.endsWith('.opencode')) {
+        log.debug(
+          'Skipping .opencode directory (using .link-assistant-agent):',
+          {
+            path: dir,
+          }
+        );
+        return false;
+      }
+      return true;
+    });
+
+    const directories = [Global.Path.config, ...filteredDirs];
 
     if (Flag.OPENCODE_CONFIG_DIR) {
       directories.push(Flag.OPENCODE_CONFIG_DIR);
-      log.debug('loading config from OPENCODE_CONFIG_DIR', {
+      log.debug('loading config from LINK_ASSISTANT_AGENT_CONFIG_DIR', {
         path: Flag.OPENCODE_CONFIG_DIR,
       });
     }
@@ -86,7 +206,11 @@ export namespace Config {
     for (const dir of directories) {
       await assertValid(dir);
 
-      if (dir.endsWith('.opencode') || dir === Flag.OPENCODE_CONFIG_DIR) {
+      if (
+        dir.endsWith('.link-assistant-agent') ||
+        dir.endsWith('.opencode') ||
+        dir === Flag.OPENCODE_CONFIG_DIR
+      ) {
         for (const file of ['opencode.jsonc', 'opencode.json']) {
           log.debug(`loading config from ${path.join(dir, file)}`);
           result = mergeDeep(result, await loadFile(path.join(dir, file)));
@@ -162,7 +286,11 @@ export namespace Config {
       if (!md.data) continue;
 
       const name = (() => {
-        const patterns = ['/.opencode/command/', '/command/'];
+        const patterns = [
+          '/.link-assistant-agent/command/',
+          '/.opencode/command/',
+          '/command/',
+        ];
         const pattern = patterns.find((p) => item.includes(p));
 
         if (pattern) {
@@ -202,11 +330,13 @@ export namespace Config {
 
       // Extract relative path from agent folder for nested agents
       let agentName = path.basename(item, '.md');
-      const agentFolderPath = item.includes('/.opencode/agent/')
-        ? item.split('/.opencode/agent/')[1]
-        : item.includes('/agent/')
-          ? item.split('/agent/')[1]
-          : agentName + '.md';
+      const agentFolderPath = item.includes('/.link-assistant-agent/agent/')
+        ? item.split('/.link-assistant-agent/agent/')[1]
+        : item.includes('/.opencode/agent/')
+          ? item.split('/.opencode/agent/')[1]
+          : item.includes('/agent/')
+            ? item.split('/agent/')[1]
+            : agentName + '.md';
 
       // If agent is in a subfolder, include folder path in name
       if (agentFolderPath.includes('/')) {

package/src/flag/flag.ts

@@ -1,32 +1,78 @@
 export namespace Flag {
-  // OPENCODE_AUTO_SHARE removed - no sharing support
-  export const OPENCODE_CONFIG = process.env['OPENCODE_CONFIG'];
-  export const OPENCODE_CONFIG_DIR = process.env['OPENCODE_CONFIG_DIR'];
-  export const OPENCODE_CONFIG_CONTENT = process.env['OPENCODE_CONFIG_CONTENT'];
-  export const OPENCODE_DISABLE_AUTOUPDATE = truthy(
+  // Helper to check env vars with new prefix first, then fall back to old prefix for backwards compatibility
+  function getEnv(newKey: string, oldKey: string): string | undefined {
+    return process.env[newKey] ?? process.env[oldKey];
+  }
+
+  function truthyCompat(newKey: string, oldKey: string): boolean {
+    const value = (getEnv(newKey, oldKey) ?? '').toLowerCase();
+    return value === 'true' || value === '1';
+  }
+
+  // LINK_ASSISTANT_AGENT_AUTO_SHARE removed - no sharing support
+  export const OPENCODE_CONFIG = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG',
+    'OPENCODE_CONFIG'
+  );
+  export const OPENCODE_CONFIG_DIR = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG_DIR',
+    'OPENCODE_CONFIG_DIR'
+  );
+  export const OPENCODE_CONFIG_CONTENT = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG_CONTENT',
+    'OPENCODE_CONFIG_CONTENT'
+  );
+  export const OPENCODE_DISABLE_AUTOUPDATE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_AUTOUPDATE',
     'OPENCODE_DISABLE_AUTOUPDATE'
   );
-  export const OPENCODE_DISABLE_PRUNE = truthy('OPENCODE_DISABLE_PRUNE');
-  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy(
+  export const OPENCODE_DISABLE_PRUNE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_PRUNE',
+    'OPENCODE_DISABLE_PRUNE'
+  );
+  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthyCompat(
+    'LINK_ASSISTANT_AGENT_ENABLE_EXPERIMENTAL_MODELS',
     'OPENCODE_ENABLE_EXPERIMENTAL_MODELS'
   );
-  export const OPENCODE_DISABLE_AUTOCOMPACT = truthy(
+  export const OPENCODE_DISABLE_AUTOCOMPACT = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_AUTOCOMPACT',
     'OPENCODE_DISABLE_AUTOCOMPACT'
   );
 
   // Experimental
-  export const OPENCODE_EXPERIMENTAL = truthy('OPENCODE_EXPERIMENTAL');
+  export const OPENCODE_EXPERIMENTAL = truthyCompat(
+    'LINK_ASSISTANT_AGENT_EXPERIMENTAL',
+    'OPENCODE_EXPERIMENTAL'
+  );
   export const OPENCODE_EXPERIMENTAL_WATCHER =
-    OPENCODE_EXPERIMENTAL || truthy('OPENCODE_EXPERIMENTAL_WATCHER');
+    OPENCODE_EXPERIMENTAL ||
+    truthyCompat(
+      'LINK_ASSISTANT_AGENT_EXPERIMENTAL_WATCHER',
+      'OPENCODE_EXPERIMENTAL_WATCHER'
+    );
 
   // Verbose mode - enables detailed logging of API requests
-  export let OPENCODE_VERBOSE = truthy('OPENCODE_VERBOSE');
+  export let OPENCODE_VERBOSE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_VERBOSE',
+    'OPENCODE_VERBOSE'
+  );
+
+  // Dry run mode - simulate operations without making actual API calls or changes
+  export let OPENCODE_DRY_RUN = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DRY_RUN',
+    'OPENCODE_DRY_RUN'
+  );
 
   // Allow setting verbose mode programmatically (e.g., from CLI --verbose flag)
   export function setVerbose(value: boolean) {
     OPENCODE_VERBOSE = value;
   }
 
+  // Allow setting dry run mode programmatically (e.g., from CLI --dry-run flag)
+  export function setDryRun(value: boolean) {
+    OPENCODE_DRY_RUN = value;
+  }
+
   function truthy(key: string) {
     const value = process.env[key]?.toLowerCase();
     return value === 'true' || value === '1';

package/src/global/index.ts

@@ -3,7 +3,7 @@ import { xdgData, xdgCache, xdgConfig, xdgState } from 'xdg-basedir';
 import path from 'path';
 import os from 'os';
 
-const app = 'opencode';
+const app = 'link-assistant-agent';
 
 const data = path.join(xdgData!, app);
 const cache = path.join(xdgCache!, app);
@@ -24,6 +24,7 @@ export namespace Global {
 
 await Promise.all([
   fs.mkdir(Global.Path.data, { recursive: true }),
+  fs.mkdir(Global.Path.cache, { recursive: true }),
   fs.mkdir(Global.Path.config, { recursive: true }),
   fs.mkdir(Global.Path.state, { recursive: true }),
   fs.mkdir(Global.Path.log, { recursive: true }),

package/src/index.js

@@ -110,6 +110,13 @@ async function runAgentMode(argv) {
     console.error(`Script path: ${import.meta.path}`);
   }
 
+  // Log dry-run mode if enabled
+  if (Flag.OPENCODE_DRY_RUN) {
+    console.error(
+      `[DRY RUN MODE] No actual API calls or package installations will be made`
+    );
+  }
+
   // Parse model argument (handle model IDs with slashes like groq/qwen/qwen3-32b)
   const modelParts = argv.model.split('/');
   let providerID = modelParts[0] || 'opencode';
@@ -574,6 +581,12 @@ async function main() {
           'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
         default: false,
       })
+      .option('dry-run', {
+        type: 'boolean',
+        description:
+          'Simulate operations without making actual API calls or package installations (useful for testing)',
+        default: false,
+      })
       .option('use-existing-claude-oauth', {
         type: 'boolean',
         description:
@@ -588,6 +601,11 @@ async function main() {
           Flag.setVerbose(true);
         }
 
+        // Set dry-run flag if requested
+        if (argv['dry-run']) {
+          Flag.setDryRun(true);
+        }
+
         // Initialize logging system
         // - If verbose: print logs to stderr for debugging
         // - Otherwise: write logs to file to keep CLI output clean

package/src/provider/provider.ts

@@ -721,7 +721,17 @@ export namespace Provider {
 
       let installedPath: string;
       if (!pkg.startsWith('file://')) {
+        log.info('installing provider package', {
+          providerID: provider.id,
+          pkg,
+          version: 'latest',
+        });
         installedPath = await BunProc.install(pkg, 'latest');
+        log.info('provider package installed successfully', {
+          providerID: provider.id,
+          pkg,
+          installedPath,
+        });
       } else {
         log.info('loading local provider', { pkg });
         installedPath = pkg;
@@ -769,6 +779,13 @@ export namespace Provider {
       s.sdk.set(key, loaded);
       return loaded as SDK;
     })().catch((e) => {
+      log.error('provider initialization failed', {
+        providerID: provider.id,
+        pkg: model.provider?.npm ?? provider.npm ?? provider.id,
+        error: e instanceof Error ? e.message : String(e),
+        stack: e instanceof Error ? e.stack : undefined,
+        cause: e instanceof Error && e.cause ? String(e.cause) : undefined,
+      });
       throw new InitError({ providerID: provider.id }, { cause: e });
     });
   }
@@ -859,7 +876,13 @@ export namespace Provider {
     }
   }
 
-  const priority = ['gpt-5', 'claude-sonnet-4', 'big-pickle', 'gemini-3-pro'];
+  const priority = [
+    'grok-code',
+    'gpt-5',
+    'claude-sonnet-4',
+    'big-pickle',
+    'gemini-3-pro',
+  ];
   export function sort(models: ModelsDev.Model[]) {
     return sortBy(
       models,
@@ -876,13 +899,23 @@ export namespace Provider {
     const cfg = await Config.get();
     if (cfg.model) return parseModel(cfg.model);
 
-    const provider = await list()
-      .then((val) => Object.values(val))
-      .then((x) =>
-        x.find(
-          (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
-        )
-      );
+    // Prefer opencode provider if available
+    const providers = await list().then((val) => Object.values(val));
+    const opencodeProvider = providers.find((p) => p.info.id === 'opencode');
+    if (opencodeProvider) {
+      const [model] = sort(Object.values(opencodeProvider.info.models));
+      if (model) {
+        return {
+          providerID: opencodeProvider.info.id,
+          modelID: model.id,
+        };
+      }
+    }
+
+    // Fall back to any available provider
+    const provider = providers.find(
+      (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
+    );
     if (!provider) throw new Error('no providers found');
     const [model] = sort(Object.values(provider.info.models));
     if (!model) throw new Error('no models found');