prjct-cli 0.60.1 → 0.60.2

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.60.2] - 2026-02-05
+
+### Performance
+
+- parallelize agent/skill loading with Promise.all (PRJ-110) (#101)
+
+
+## [0.60.2] - 2026-02-05
+
+### Performance
+
+- **Parallel agent/skill loading (PRJ-110)**: Agent and skill loading now uses `Promise.all` for parallel I/O
+
+### Implementation Details
+
+Refactored `loadAgents()` and `loadSkills()` in `core/agentic/orchestrator-executor.ts` to use `Promise.all` with map instead of sequential for loops. Also parallelized `loadAllAgents()` in `core/domain/agent-loader.ts`. Pattern: collect items → map to async promises → Promise.all → filter nulls with type guard.
+
+### Learnings
+
+- Use `Promise.all(items.map(async (item) => ...))` for parallel async operations
+- Return null for failed items, then filter - can't push to array in parallel
+- Collect unique items first (deduplication), then parallelize reads
+
+### Test Plan
+
+#### For QA
+1. Run `prjct sync --yes` - verify agents load successfully
+2. Run `p. task "test"` - verify orchestrator works
+3. Check no errors in agent/skill loading output
+
+#### For Users
+- Agent and skill loading is now faster (parallel I/O)
+- No changes needed - improvement is automatic
+
+
 ## [0.60.1] - 2026-02-05
 
 ### Bug Fixes

package/core/agentic/orchestrator-executor.ts

@@ -341,13 +341,15 @@ export class OrchestratorExecutor {
    *
    * Reads agent markdown files from {globalPath}/agents/
    * and extracts their content and skills from frontmatter.
+   *
+   * Uses parallel file reads for performance (PRJ-110).
    */
   async loadAgents(domains: string[], projectId: string): Promise<LoadedAgent[]> {
     const globalPath = pathManager.getGlobalProjectPath(projectId)
     const agentsDir = path.join(globalPath, 'agents')
-    const agents: LoadedAgent[] = []
 
-    for (const domain of domains) {
+    // Load all domain agents in parallel
+    const agentPromises = domains.map(async (domain): Promise<LoadedAgent | null> => {
       // Try exact match first, then variations
       const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`]
 
@@ -357,21 +359,22 @@ export class OrchestratorExecutor {
           const content = await fs.readFile(filePath, 'utf-8')
           const { frontmatter, body } = this.parseAgentFile(content)
 
-          agents.push({
+          return {
             name: fileName.replace('.md', ''),
             domain,
             content: body,
             skills: frontmatter.skills || [],
             filePath,
-          })
-
-          // Found one, no need to try other variations
-          break
-        } catch {}
+          }
+        } catch {
+          // Try next variation
+        }
       }
-    }
+      return null
+    })
 
-    return agents
+    const results = await Promise.all(agentPromises)
+    return results.filter((agent): agent is LoadedAgent => agent !== null)
   }
 
   /**
@@ -400,51 +403,46 @@ export class OrchestratorExecutor {
    * Load skills from agent frontmatter
    *
    * Skills are stored in ~/.claude/skills/{name}.md
+   *
+   * Uses parallel file reads for performance (PRJ-110).
    */
   async loadSkills(agents: LoadedAgent[]): Promise<LoadedSkill[]> {
     const skillsDir = path.join(os.homedir(), '.claude', 'skills')
-    const skills: LoadedSkill[] = []
-    const loadedSkillNames = new Set<string>()
 
+    // Collect unique skill names from all agents
+    const uniqueSkillNames = new Set<string>()
     for (const agent of agents) {
       for (const skillName of agent.skills) {
-        // Skip if already loaded
-        if (loadedSkillNames.has(skillName)) continue
+        uniqueSkillNames.add(skillName)
+      }
+    }
 
+    // Load all skills in parallel
+    const skillPromises = Array.from(uniqueSkillNames).map(
+      async (skillName): Promise<LoadedSkill | null> => {
         // Check both patterns: flat file and subdirectory (ecosystem standard)
         const flatPath = path.join(skillsDir, `${skillName}.md`)
         const subdirPath = path.join(skillsDir, skillName, 'SKILL.md')
 
-        let content: string | null = null
-        let resolvedPath = flatPath
-
         // Prefer subdirectory format (ecosystem standard)
         try {
-          content = await fs.readFile(subdirPath, 'utf-8')
-          resolvedPath = subdirPath
+          const content = await fs.readFile(subdirPath, 'utf-8')
+          return { name: skillName, content, filePath: subdirPath }
         } catch {
           // Fall back to flat file
           try {
-            content = await fs.readFile(flatPath, 'utf-8')
-            resolvedPath = flatPath
+            const content = await fs.readFile(flatPath, 'utf-8')
+            return { name: skillName, content, filePath: flatPath }
           } catch {
             // Skill not found - not an error, just skip
-            console.warn(`Skill not found: ${skillName}`)
+            return null
           }
         }
-
-        if (content) {
-          skills.push({
-            name: skillName,
-            content,
-            filePath: resolvedPath,
-          })
-          loadedSkillNames.add(skillName)
-        }
       }
-    }
+    )
 
-    return skills
+    const results = await Promise.all(skillPromises)
+    return results.filter((skill): skill is LoadedSkill => skill !== null)
   }
 
   /**

package/core/domain/agent-loader.ts

@@ -94,22 +94,22 @@ class AgentLoader {
 
   /**
    * Load all agents for the project
+   *
+   * Uses parallel file reads for performance (PRJ-110).
    */
   async loadAllAgents(): Promise<Agent[]> {
     try {
       const files = await fs.readdir(this.agentsDir)
       const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
 
-      const agents: Agent[] = []
-      for (const file of agentFiles) {
+      // Load all agents in parallel
+      const agentPromises = agentFiles.map((file) => {
         const agentName = file.replace('.md', '')
-        const agent = await this.loadAgent(agentName)
-        if (agent) {
-          agents.push(agent)
-        }
-      }
+        return this.loadAgent(agentName)
+      })
 
-      return agents
+      const results = await Promise.all(agentPromises)
+      return results.filter((agent): agent is Agent => agent !== null)
     } catch (error) {
       if (isNotFoundError(error)) {
         return [] // Agents directory doesn't exist yet

package/dist/bin/prjct.mjs

@@ -11788,31 +11788,33 @@ var init_orchestrator_executor = __esm({
        *
        * Reads agent markdown files from {globalPath}/agents/
        * and extracts their content and skills from frontmatter.
+       *
+       * Uses parallel file reads for performance (PRJ-110).
        */
       async loadAgents(domains, projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
         const agentsDir = path23.join(globalPath, "agents");
-        const agents = [];
-        for (const domain of domains) {
+        const agentPromises = domains.map(async (domain) => {
           const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`];
           for (const fileName of possibleNames) {
             const filePath = path23.join(agentsDir, fileName);
             try {
               const content = await fs24.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
-              agents.push({
+              return {
                 name: fileName.replace(".md", ""),
                 domain,
                 content: body,
                 skills: frontmatter.skills || [],
                 filePath
-              });
-              break;
+              };
             } catch {
             }
           }
-        }
-        return agents;
+          return null;
+        });
+        const results = await Promise.all(agentPromises);
+        return results.filter((agent) => agent !== null);
       }
       /**
        * Parse agent markdown file to extract frontmatter and body
@@ -11832,40 +11834,36 @@ var init_orchestrator_executor = __esm({
        * Load skills from agent frontmatter
        *
        * Skills are stored in ~/.claude/skills/{name}.md
+       *
+       * Uses parallel file reads for performance (PRJ-110).
        */
       async loadSkills(agents) {
         const skillsDir = path23.join(os8.homedir(), ".claude", "skills");
-        const skills = [];
-        const loadedSkillNames = /* @__PURE__ */ new Set();
+        const uniqueSkillNames = /* @__PURE__ */ new Set();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
-            if (loadedSkillNames.has(skillName)) continue;
+            uniqueSkillNames.add(skillName);
+          }
+        }
+        const skillPromises = Array.from(uniqueSkillNames).map(
+          async (skillName) => {
             const flatPath = path23.join(skillsDir, `${skillName}.md`);
             const subdirPath = path23.join(skillsDir, skillName, "SKILL.md");
-            let content = null;
-            let resolvedPath = flatPath;
             try {
-              content = await fs24.readFile(subdirPath, "utf-8");
-              resolvedPath = subdirPath;
+              const content = await fs24.readFile(subdirPath, "utf-8");
+              return { name: skillName, content, filePath: subdirPath };
             } catch {
               try {
-                content = await fs24.readFile(flatPath, "utf-8");
-                resolvedPath = flatPath;
+                const content = await fs24.readFile(flatPath, "utf-8");
+                return { name: skillName, content, filePath: flatPath };
               } catch {
-                console.warn(`Skill not found: ${skillName}`);
+                return null;
               }
             }
-            if (content) {
-              skills.push({
-                name: skillName,
-                content,
-                filePath: resolvedPath
-              });
-              loadedSkillNames.add(skillName);
-            }
           }
-        }
-        return skills;
+        );
+        const results = await Promise.all(skillPromises);
+        return results.filter((skill) => skill !== null);
       }
       /**
        * Determine if task should be fragmented into subtasks
@@ -26412,7 +26410,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.60.1",
+      version: "0.60.2",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.60.1",
+  "version": "0.60.2",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {