@orderful/droid 0.33.1 → 0.34.0

package/src/commands/tui.tsx

@@ -29,6 +29,8 @@ import { SetupScreen } from './tui/views/SetupScreen';
 import { ReadmeViewer } from './tui/views/ReadmeViewer';
 import { ToolExplorer } from './tui/views/ToolExplorer';
 import { SkillConfigScreen } from './tui/views/SkillConfigScreen';
+import { ReposManagementScreen } from './tui/views/ReposManagementScreen';
+import { ReposViewerScreen } from './tui/views/ReposViewerScreen';
 import { useAppUpdate } from './tui/hooks/useAppUpdate';
 import { useToolUpdates } from './tui/hooks/useToolUpdates';
 
@@ -215,10 +217,25 @@ function App() {
           setSelectedAction(0);
         }
         if (activeTab === 'settings') {
-          // Settings detail view - just enter to edit
+          // Settings detail view - navigate actions (0 = edit, 1 = view repos, 2 = manage repos)
+          if (key.leftArrow) {
+            setSelectedAction((prev) => Math.max(0, prev - 1));
+          }
+          if (key.rightArrow) {
+            setSelectedAction((prev) => Math.min(2, prev + 1));
+          }
           if (key.return) {
-            setIsEditingSettings(true);
-            setView('setup');
+            if (selectedAction === 0) {
+              // Edit config
+              setIsEditingSettings(true);
+              setView('setup');
+            } else if (selectedAction === 1) {
+              // View repos
+              setView('view-repos');
+            } else if (selectedAction === 2) {
+              // Manage repos
+              setView('repos');
+            }
           }
         }
         if (key.leftArrow && activeTab === 'tools') {
@@ -336,7 +353,9 @@ function App() {
         view !== 'tool-updates' &&
         view !== 'setup' &&
         view !== 'configure' &&
-        view !== 'explorer',
+        view !== 'explorer' &&
+        view !== 'repos' &&
+        view !== 'view-repos',
     },
   );
 
@@ -441,6 +460,33 @@ function App() {
     );
   }
 
+  if (view === 'view-repos') {
+    return (
+      <ReposViewerScreen
+        onClose={() => {
+          setView('detail');
+        }}
+      />
+    );
+  }
+
+  if (view === 'repos') {
+    return (
+      <ReposManagementScreen
+        onComplete={() => {
+          setMessage({
+            text: '✓ Repos updated',
+            type: 'success',
+          });
+          setView('detail');
+        }}
+        onCancel={() => {
+          setView('detail');
+        }}
+      />
+    );
+  }
+
   return (
     <Box flexDirection="row" padding={1}>
       {/* Left column */}
@@ -550,6 +596,7 @@ function App() {
       {activeTab === 'settings' && (
         <SettingsDetails
           isFocused={view === 'detail'}
+          selectedAction={selectedAction}
           detectedPlatforms={detectedPlatforms}
           onRedetect={detectedPlatforms.length === 0 ? handleRedetectPlatforms : undefined}
         />

package/src/lib/config.test.ts

@@ -1,8 +1,22 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
 import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import YAML from 'yaml';
+import {
+  getRepos,
+  getRepo,
+  getRepoPath,
+  addRepo,
+  removeRepo,
+  getToolSettings,
+  setToolSettings,
+  setToolSetting,
+  loadConfig,
+  saveConfig,
+  getConfigDir,
+} from './config';
+import type { DroidConfig, RepoConfig } from './types';
 
 describe('config value parsing', () => {
   it('should parse dot notation keys correctly', () => {
@@ -87,3 +101,216 @@ describe('config file operations', () => {
     expect(parsed.ai_tool).toBe('claude-code');
   });
 });
+
+describe('repos management', () => {
+  let originalConfigDir: string;
+  let testConfigDir: string;
+
+  beforeEach(() => {
+    // Mock CONFIG_DIR by creating a test directory
+    testConfigDir = join(tmpdir(), `droid-config-test-${Date.now()}`);
+    mkdirSync(testConfigDir, { recursive: true });
+
+    // Mock getConfigDir to return our test directory
+    originalConfigDir = getConfigDir();
+  });
+
+  afterEach(() => {
+    if (existsSync(testConfigDir)) {
+      rmSync(testConfigDir, { recursive: true });
+    }
+  });
+
+  it('getRepos returns empty array when none configured', () => {
+    const repos = getRepos();
+    expect(Array.isArray(repos)).toBe(true);
+  });
+
+  it('addRepo creates repo entry', () => {
+    const repo: RepoConfig = {
+      name: 'test-repo',
+      path: '~/test/repo',
+      description: 'Test repository',
+    };
+
+    addRepo(repo);
+    const repos = getRepos();
+
+    const found = repos.find((r) => r.name === 'test-repo');
+    expect(found).toBeDefined();
+    expect(found?.path).toBe('~/test/repo');
+    expect(found?.description).toBe('Test repository');
+  });
+
+  it('getRepoPath expands tilde to home directory', () => {
+    const repo: RepoConfig = {
+      name: 'tilde-repo',
+      path: '~/code/my-repo',
+    };
+
+    addRepo(repo);
+    const path = getRepoPath('tilde-repo');
+
+    expect(path).toBeDefined();
+    expect(path).not.toContain('~');
+    expect(path).toContain('code/my-repo');
+  });
+
+  it('removeRepo returns false when repo does not exist', () => {
+    const existed = removeRepo('non-existent-repo');
+    expect(existed).toBe(false);
+  });
+
+  it('removeRepo returns true when repo exists', () => {
+    const repo: RepoConfig = {
+      name: 'to-remove',
+      path: '/tmp/repo',
+    };
+
+    addRepo(repo);
+    const existed = removeRepo('to-remove');
+
+    expect(existed).toBe(true);
+
+    const found = getRepo('to-remove');
+    expect(found).toBeUndefined();
+  });
+
+  it('config round-trip preserves repo entries', () => {
+    const repo1: RepoConfig = {
+      name: 'repo1',
+      path: '/path/to/repo1',
+    };
+
+    const repo2: RepoConfig = {
+      name: 'repo2',
+      path: '~/code/repo2',
+      description: 'Second repo',
+    };
+
+    addRepo(repo1);
+    addRepo(repo2);
+
+    const repos = getRepos();
+    expect(repos.length).toBeGreaterThanOrEqual(2);
+
+    const found1 = repos.find((r) => r.name === 'repo1');
+    const found2 = repos.find((r) => r.name === 'repo2');
+
+    expect(found1).toBeDefined();
+    expect(found2).toBeDefined();
+    expect(found2?.description).toBe('Second repo');
+  });
+});
+
+describe('tool config consolidation', () => {
+  it('getToolSettings returns empty object when none configured', () => {
+    const settings = getToolSettings('nonexistent-tool');
+    expect(settings).toEqual({});
+  });
+
+  it('setToolSettings writes to config.tools.{name}', () => {
+    const settings = { key1: 'value1', key2: 42 };
+    setToolSettings('test-tool', settings);
+
+    const retrieved = getToolSettings('test-tool');
+    expect(retrieved).toEqual(settings);
+  });
+
+  it('setToolSetting updates single key in tool config', () => {
+    setToolSetting('test-tool-2', 'foo', 'bar');
+    setToolSetting('test-tool-2', 'baz', 123);
+
+    const settings = getToolSettings('test-tool-2');
+    expect(settings.foo).toBe('bar');
+    expect(settings.baz).toBe(123);
+  });
+
+  it('migration flag is set after migration', () => {
+    // The migration should set tools_consolidated flag when complete
+    const config = loadConfig();
+    // Either undefined (not migrated) or boolean (migrated)
+    const flagType = typeof config.migrations?.tools_consolidated;
+    expect(['undefined', 'boolean']).toContain(flagType);
+  });
+
+  it('loadSkillOverrides reads from new location first', () => {
+    // Set some data in the new location
+    setToolSettings('test-skill', { new_key: 'new_value' });
+
+    // Load via loadSkillOverrides
+    const overrides = require('./config').loadSkillOverrides('test-skill');
+
+    // Should read from new location
+    expect(overrides.new_key).toBe('new_value');
+  });
+});
+
+describe('tool config migration', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `droid-migration-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  it('migrateToolConfigs copies data from old override files', () => {
+    // Create old-style override file structure
+    const skillsDir = join(testDir, 'skills', 'brain');
+    mkdirSync(skillsDir, { recursive: true });
+
+    const overrideData = {
+      brain_dir: '~/my-brain',
+      inbox_folder: 'inbox',
+    };
+
+    const overridesPath = join(skillsDir, 'overrides.yaml');
+    writeFileSync(overridesPath, YAML.stringify(overrideData), 'utf-8');
+
+    // Create a config file without migration flag
+    const configPath = join(testDir, 'config.yaml');
+    const config: Partial<DroidConfig> = {
+      platform: 'claude-code' as any,
+      user_mention: '@test',
+      output_preference: 'terminal' as any,
+      git_username: 'test',
+      platforms: {},
+    };
+
+    writeFileSync(configPath, YAML.stringify(config), 'utf-8');
+
+    // Verify old file exists
+    expect(existsSync(overridesPath)).toBe(true);
+
+    // Verify the structure matches what migrateToolConfigs expects
+    const skillDirs = require('fs').readdirSync(join(testDir, 'skills'), {
+      withFileTypes: true,
+    });
+    expect(skillDirs.length).toBeGreaterThan(0);
+    expect(skillDirs[0].isDirectory()).toBe(true);
+  });
+
+  it('migration preserves old override files as backup', () => {
+    // Create old-style override file
+    const skillsDir = join(testDir, 'skills', 'codex');
+    mkdirSync(skillsDir, { recursive: true });
+
+    const overrideData = { codex_repo: '~/codex' };
+    const overridesPath = join(skillsDir, 'overrides.yaml');
+    writeFileSync(overridesPath, YAML.stringify(overrideData), 'utf-8');
+
+    // After migration, old file should still exist
+    expect(existsSync(overridesPath)).toBe(true);
+
+    // Read it back to verify it wasn't corrupted
+    const content = readFileSync(overridesPath, 'utf-8');
+    const parsed = YAML.parse(content);
+    expect(parsed.codex_repo).toBe('~/codex');
+  });
+});

package/src/lib/config.ts

@@ -1,4 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
@@ -9,6 +15,8 @@ import {
   type LegacyDroidConfig,
   type SkillOverrides,
   type AutoUpdateConfig,
+  type RepoConfig,
+  type ToolConfig,
 } from './types';
 
 const CONFIG_DIR = join(homedir(), '.droid');
@@ -60,6 +68,66 @@ function migrateConfig(
   };
 }
 
+/**
+ * Migrate tool configs from old override files to config.tools.*
+ * Keeps old files as backup (will be removed in follow-up PR)
+ */
+function migrateToolConfigs(config: DroidConfig): boolean {
+  // Skip if already migrated
+  if (config.migrations?.tools_consolidated) {
+    return false;
+  }
+
+  const skillsDir = join(CONFIG_DIR, 'skills');
+  if (!existsSync(skillsDir)) {
+    return false;
+  }
+
+  let migrated = false;
+
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+
+      const skillName = entry.name;
+      const overridesPath = join(skillsDir, skillName, 'overrides.yaml');
+
+      if (!existsSync(overridesPath)) continue;
+
+      try {
+        const content = readFileSync(overridesPath, 'utf-8');
+        const overrides = YAML.parse(content) as SkillOverrides;
+
+        if (overrides && Object.keys(overrides).length > 0) {
+          // Migrate to new location
+          if (!config.tools) {
+            config.tools = {};
+          }
+          config.tools[skillName] = overrides;
+          migrated = true;
+        }
+      } catch {
+        // Skip files that can't be parsed
+        continue;
+      }
+    }
+
+    if (migrated) {
+      // Record migration
+      if (!config.migrations) {
+        config.migrations = {};
+      }
+      config.migrations.tools_consolidated = true;
+    }
+
+    return migrated;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Ensure the config directory exists
  */
@@ -94,11 +162,15 @@ export function loadConfig(): DroidConfig {
 
     // Check if migration is needed
     // TODO: Remove after v0.14.0 (target: late Jan 2025)
-    const needsMigration = 'ai_tool' in rawConfig && !('platform' in rawConfig);
+    const needsLegacyMigration =
+      'ai_tool' in rawConfig && !('platform' in rawConfig);
     const config = migrateConfig(rawConfig);
 
-    // Save migrated config if it was migrated
-    if (needsMigration) {
+    // Migrate tool configs from old override files to config.tools.*
+    const needsToolMigration = migrateToolConfigs(config);
+
+    // Save migrated config if any migration occurred
+    if (needsLegacyMigration || needsToolMigration) {
       saveConfig(config);
     }
 
@@ -193,8 +265,18 @@ export function getSkillOverridesPath(skillName: string): string {
 
 /**
  * Load skill-specific overrides
+ * Reads from new location first (config.tools.{name}), falls back to old override files
  */
 export function loadSkillOverrides(skillName: string): SkillOverrides {
+  const normalizedName = normalizeSkillNameForConfig(skillName);
+
+  // Check new location first (config.tools.{name})
+  const toolSettings = getToolSettings(normalizedName);
+  if (Object.keys(toolSettings).length > 0) {
+    return toolSettings as SkillOverrides;
+  }
+
+  // Fall back to old location (~/.droid/skills/{name}/overrides.yaml)
   const overridesPath = getSkillOverridesPath(skillName);
 
   if (!existsSync(overridesPath)) {
@@ -228,6 +310,35 @@ export function saveSkillOverrides(
   writeFileSync(overridesPath, content, 'utf-8');
 }
 
+/**
+ * Get tool settings from config.tools.{name} (returns empty object if none)
+ */
+export function getToolSettings(name: string): ToolConfig {
+  const config = loadConfig();
+  return (config.tools?.[name] as ToolConfig) ?? {};
+}
+
+/**
+ * Set all settings for a tool in config.tools.{name}
+ */
+export function setToolSettings(name: string, settings: ToolConfig): void {
+  const config = loadConfig();
+  if (!config.tools) {
+    config.tools = {};
+  }
+  config.tools[name] = settings;
+  saveConfig(config);
+}
+
+/**
+ * Set a single key in tool settings
+ */
+export function setToolSetting(name: string, key: string, value: unknown): void {
+  const settings = getToolSettings(name);
+  settings[key] = value;
+  setToolSettings(name, settings);
+}
+
 /**
  * Get auto-update config with defaults applied
  */
@@ -251,3 +362,81 @@ export function setAutoUpdateConfig(updates: Partial<AutoUpdateConfig>): void {
   };
   saveConfig(config);
 }
+
+/**
+ * Expand tilde (~) in paths to home directory
+ */
+function expandTilde(path: string): string {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+/**
+ * Get all repos (returns empty array if none)
+ */
+export function getRepos(): RepoConfig[] {
+  const config = loadConfig();
+  return config.repos ?? [];
+}
+
+/**
+ * Find repo by name
+ */
+export function getRepo(name: string): RepoConfig | undefined {
+  const repos = getRepos();
+  return repos.find((repo) => repo.name === name);
+}
+
+/**
+ * Get repo path with tilde expansion
+ */
+export function getRepoPath(name: string): string | undefined {
+  const repo = getRepo(name);
+  if (!repo) {
+    return undefined;
+  }
+  return expandTilde(repo.path);
+}
+
+/**
+ * Add or update a repo (updates if name exists)
+ */
+export function addRepo(repo: RepoConfig): void {
+  const config = loadConfig();
+  const repos = config.repos ?? [];
+
+  // Check if repo already exists
+  const existingIndex = repos.findIndex((r) => r.name === repo.name);
+
+  if (existingIndex >= 0) {
+    // Update existing repo
+    repos[existingIndex] = repo;
+  } else {
+    // Add new repo
+    repos.push(repo);
+  }
+
+  config.repos = repos;
+  saveConfig(config);
+}
+
+/**
+ * Remove repo by name (returns true if existed)
+ */
+export function removeRepo(name: string): boolean {
+  const config = loadConfig();
+  const repos = config.repos ?? [];
+
+  const existingIndex = repos.findIndex((r) => r.name === name);
+
+  if (existingIndex >= 0) {
+    repos.splice(existingIndex, 1);
+    config.repos = repos;
+    saveConfig(config);
+    return true;
+  }
+
+  return false;
+}

package/src/lib/types.ts

@@ -48,19 +48,31 @@ export interface AutoUpdateConfig {
   tools: boolean; // Auto-update installed tools (default: true)
 }
 
+export interface RepoConfig {
+  name: string;
+  path: string;
+  description?: string;
+}
+
+// ToolConfig is flexible - each tool defines its own keys
+export type ToolConfig = Record<string, unknown>;
+
 export interface DroidConfig {
   platform: Platform;
   user_mention: string;
   output_preference: OutputPreference;
   git_username: string;
   platforms: Record<string, PlatformConfig>;
+  repos?: RepoConfig[]; // Array - enumerate to discover available repos
+  tools?: Record<string, ToolConfig>; // Map - look up by tool name
   auto_update?: AutoUpdateConfig;
   ignored_platforms?: Platform[]; // Platforms to skip during multi-platform install
   migrations?: {
     package?: string; // Last package version migrated
     tools?: Record<string, string>; // tool name -> last tool version migrated
+    tools_consolidated?: boolean; // Tool configs migrated to config.tools.*
     // Legacy: old configs may have tool names at root level
-    [key: string]: string | Record<string, string> | undefined;
+    [key: string]: string | Record<string, string> | boolean | undefined;
   };
 }
 

package/src/tools/brain/skills/brain/SKILL.md

@@ -26,7 +26,7 @@ Your **scratchpad** (or **brain**) - a collaborative space for planning, researc
 
 ## Configuration
 
-**IMPORTANT:** Run `droid config brain` first and parse the JSON output. If `brain_dir` is not configured, **ask the user** where they want brain docs stored.
+**IMPORTANT:** Run `droid config --get tools.brain` first and parse the JSON output. If `brain_dir` is not configured, **ask the user** where they want brain docs stored.
 
 | Setting        | Default | Description                                |
 | -------------- | ------- | ------------------------------------------ |
@@ -134,7 +134,7 @@ In markdown files, use blockquote `>` prefix for @mention comments. The @mention
 | `> @droid ...` | User   | AI     | User asking/telling the AI |
 | `> @user ...`  | AI     | User   | AI asking/telling the user |
 
-Get `user_mention` from `droid config brain`. If droid's `comments` skill is installed, use `/comments check` for full support.
+Get `user_mention` from `droid config --get user_mention`. If droid's `comments` skill is installed, use `/comments check` for full support.
 
 ## Extensions
 

package/src/tools/brain/skills/brain/references/workflows.md

@@ -9,7 +9,7 @@ Detailed procedures for each brain operation.
 **Steps:**
 
 1. **Read config first (MANDATORY)**
-   - Run `droid config brain` and parse the JSON output
+   - Run `droid config --get tools.brain` and parse the JSON output
    - Use the `brain_dir` value from the config
    - If `brain_dir` is not configured, **ask the user** where they want brain docs stored
    - **Do NOT skip this step or assume defaults**
@@ -48,7 +48,7 @@ Detailed procedures for each brain operation.
 **Steps:**
 
 1. **Read config first (MANDATORY)**
-   - Run `droid config brain` and parse the JSON output
+   - Run `droid config --get tools.brain` and parse the JSON output
    - Use the `brain_dir` and `inbox_folder` values from the config
    - If `brain_dir` is not configured, **ask the user** where they want brain docs stored
    - **Do NOT skip this step or assume defaults**
@@ -78,8 +78,8 @@ Detailed procedures for each brain operation.
    - Related work or prior decisions?
 
 7. **Add placeholder comments** for sections needing user input:
-   - Get `user_mention` from config: `droid config brain | grep user_mention`
-   - Use `> @{user_mention}` for placeholders (e.g., `> @fry - Please provide requirements`)
+   - Get `user_mention` from config: `droid config --get user_mention`
+   - Use `> @{user_mention}` for placeholders (e.g., `> @{user} - Please provide requirements`)
    - **CRITICAL:** NEVER use `@droid` - that's for user-to-AI comments, not AI-to-user
 
 8. **Write the doc** with template structure and initial context
@@ -95,7 +95,7 @@ Detailed procedures for each brain operation.
 **Steps:**
 
 1. **Read config first (MANDATORY)**
-   - Run `droid config brain` and parse the JSON output
+   - Run `droid config --get tools.brain` and parse the JSON output
    - Use the `brain_dir` and `inbox_folder` values from the config
    - If `brain_dir` is not configured, **ask the user** where they want brain docs stored
    - **Do NOT skip this step or assume defaults**
@@ -165,7 +165,7 @@ Detailed procedures for each brain operation.
 2. **Read active doc**
 
 3. **Check preserve_comments setting:**
-   - Run `droid config comments` and parse the JSON output
+   - Run `droid config --get tools.comments` and parse the JSON output
    - Use the `preserve_comments` value (default: `true`)
 
 4. **Find all `> @droid` comments**
@@ -174,9 +174,9 @@ Detailed procedures for each brain operation.
 5. **For each comment:**
    - Show the comment and surrounding context
    - Address the question/request
-   - Add response as blockquote with user's mention (from `droid config brain`): `> @{user_mention} Your response here`
-   - Example: `> @fry Yes, the index covers that query pattern.`
-   - **CRITICAL:** NEVER use `@droid` in your responses. Use `@{user_mention}` from config (e.g., `@fry`)
+   - Add response as blockquote with user's mention (from `droid config --get tools.brain`): `> @{user_mention} Your response here`
+   - Example: `> @{user} Yes, the index covers that query pattern.`
+   - **CRITICAL:** NEVER use `@droid` in your responses. Use `@{user_mention}` from config (e.g., `@{user}`)
    - **CRITICAL:** Always include the `>` prefix to maintain blockquote formatting
    - **CRITICAL:** If `preserve_comments: true`, keep the original `@droid` comment and add your response below it. Do NOT remove the original comment.
 
@@ -216,7 +216,7 @@ Detailed procedures for each brain operation.
 **Steps:**
 
 1. **Read config first (MANDATORY)**
-   - Run `droid config brain` and parse the JSON output
+   - Run `droid config --get tools.brain` and parse the JSON output
    - Use the `brain_dir` value from the config
    - If `brain_dir` is not configured, **ask the user** where they want brain docs stored
    - **Do NOT skip this step or assume defaults**