@adhdev/daemon-core 0.6.51 → 0.6.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.51",
+  "version": "0.6.52",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/daemon/dev-server.ts

@@ -730,39 +730,7 @@ export class DevServer {
 
   /** Find the provider directory on disk */
   private findProviderDir(type: string): string | null {
-    const provider = this.providerLoader.getMeta(type);
-    if (!provider) return null;
-    const cat = provider.category;
-    const builtinDir = (this.providerLoader as any).builtinDirs?.[0] || path.resolve(__dirname, '../providers/_builtin');
-    const userDir = path.join(os.homedir(), '.adhdev', 'providers');
-
-    // Direct match first
-    const directCandidates = [
-      path.join(userDir, type),
-      path.join(builtinDir, cat, type),
-      path.join(builtinDir, type),
-    ];
-    for (const d of directCandidates) {
-      if (fs.existsSync(path.join(d, 'provider.json'))) return d;
-    }
-
-    // Scan category dir for matching type field
-    const catDir = path.join(builtinDir, cat);
-    if (fs.existsSync(catDir)) {
-      try {
-        for (const entry of fs.readdirSync(catDir, { withFileTypes: true })) {
-          if (!entry.isDirectory()) continue;
-          const jsonPath = path.join(catDir, entry.name, 'provider.json');
-          if (fs.existsSync(jsonPath)) {
-            try {
-              const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
-              if (data.type === type) return path.join(catDir, entry.name);
-            } catch { /* skip */ }
-          }
-        }
-      } catch { /* skip */ }
-    }
-    return null;
+    return this.providerLoader.findProviderDir(type);
   }
 
   /** GET /api/providers/:type/files — list all files in provider directory */
@@ -1140,10 +1108,9 @@ export class DevServer {
 
     let targetDir: string;
     if (location === 'user') {
-      targetDir = path.join(os.homedir(), '.adhdev', 'providers', type);
+      targetDir = this.providerLoader.getUserProviderDir(category, type);
     } else {
-      const builtinDir = (this.providerLoader as any).builtinDirs?.[0] || path.resolve(__dirname, '../providers/_builtin');
-      targetDir = path.join(builtinDir, category, type);
+      targetDir = this.providerLoader.getBuiltinProviderDir(category, type);
     }
 
     const jsonPath = path.join(targetDir, 'provider.json');
@@ -1928,7 +1895,7 @@ export class DevServer {
       this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'loading_reference', message: `레퍼런스 스크립트 로드 중 (${reference})...` } });
 
       let referenceScripts: Record<string, string> = {};
-      const builtinDir = (this.providerLoader as any).builtinDirs?.[0] || path.resolve(__dirname, '../providers/_builtin');
+      const builtinDir = this.providerLoader.getPrimaryBuiltinDir();
       const refDir = path.join(builtinDir, 'ide', reference);
       if (fs.existsSync(refDir)) {
         // Find latest versioned scripts dir

package/src/providers/provider-loader.ts

@@ -77,6 +77,87 @@ export class ProviderLoader {
 
  // ─── Public API ────────────────────────────────
 
+ /**
+ * Ordered builtin roots used for local fallback/reference data.
+ */
+  getBuiltinDirs(): string[] {
+    return [...this.builtinDirs];
+  }
+
+ /**
+ * Primary builtin root used for local scaffolding/reference flows.
+ */
+  getPrimaryBuiltinDir(): string {
+    return this.builtinDirs[0];
+  }
+
+ /**
+ * User override root (~/.adhdev/providers by default).
+ */
+  getUserDir(): string {
+    return this.userDir;
+  }
+
+ /**
+ * Auto-updated upstream root (~/.adhdev/providers/.upstream by default).
+ */
+  getUpstreamDir(): string {
+    return this.upstreamDir;
+  }
+
+ /**
+ * Provider search order for on-disk lookups.
+ * Highest-priority editable overrides come first.
+ */
+  getProviderRoots(): string[] {
+    return [this.userDir, this.upstreamDir, ...this.builtinDirs];
+  }
+
+ /**
+ * Canonical provider directory shape for a given root.
+ */
+  getProviderDir(root: string, category: ProviderCategory, type: string): string {
+    return path.join(root, category, type);
+  }
+
+ /**
+ * Canonical user override directory for a provider.
+ */
+  getUserProviderDir(category: ProviderCategory, type: string): string {
+    return this.getProviderDir(this.userDir, category, type);
+  }
+
+ /**
+ * Canonical upstream directory for a provider.
+ */
+  getUpstreamProviderDir(category: ProviderCategory, type: string): string {
+    return this.getProviderDir(this.upstreamDir, category, type);
+  }
+
+ /**
+ * Canonical builtin directory for a provider.
+ */
+  getBuiltinProviderDir(category: ProviderCategory, type: string): string {
+    return this.getProviderDir(this.getPrimaryBuiltinDir(), category, type);
+  }
+
+ /**
+ * Find the on-disk directory for a provider by type.
+ * Search order: user override → upstream → builtin fallback.
+ */
+  findProviderDir(type: string): string | null {
+    return this.findProviderDirInternal(type);
+  }
+
+ /**
+ * Resolve a file within a provider directory.
+ */
+  resolveProviderFile(type: string, ...segments: string[]): string | null {
+    const dir = this.findProviderDirInternal(type);
+    if (!dir) return null;
+    return path.join(dir, ...segments);
+  }
+
  /**
  * Load all providers (3-tier priority)
  * 1. .upstream/ (GitHub auto-download — primary source)
@@ -455,7 +536,7 @@ export class ProviderLoader {
   * Tries scripts.js first, then individual .js files.
   */
   private loadScriptsFromDir(type: string, scriptDir: string): Record<string, any> | null {
-    const providerDir = this.findProviderDir(type);
+    const providerDir = this.findProviderDirInternal(type);
     if (!providerDir) {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
@@ -857,18 +938,17 @@ export class ProviderLoader {
 
   /**
    * Find the on-disk directory for a provider by type.
-   * Checks builtinDir, upstreamDir, userDir in order.
+   * Preferred shape: root/category/type. Legacy flat root/type is kept temporarily for compatibility.
    */
-  private findProviderDir(type: string): string | null {
+  private findProviderDirInternal(type: string): string | null {
     const provider = this.providers.get(type);
     if (!provider) return null;
     const cat = provider.category;
 
-    const searchRoots = [this.userDir, this.upstreamDir, ...this.builtinDirs];
+    const searchRoots = this.getProviderRoots();
     for (const root of searchRoots) {
       if (!fs.existsSync(root)) continue;
-      // Direct: root/type or root/cat/type
-      for (const candidate of [path.join(root, type), path.join(root, cat, type)]) {
+      for (const candidate of [this.getProviderDir(root, cat, type), path.join(root, type)]) {
         if (fs.existsSync(path.join(candidate, 'provider.json'))) return candidate;
       }
       // Scan category dir for type match