@shawnstack/quickforge 1.3.25 → 1.3.26

package/server/routes/tools.mjs

@@ -2,6 +2,8 @@ import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { toolHandlers, loadSkillToolContext } from '../tools/index.mjs'
 import { createSkillTools, workspaceTools } from '../tools/definitions.mjs'
+import { createMcpToolDefinitions } from '../mcp/registry.mjs'
+import { callPluginTool, createPluginToolDefinitions, isPluginToolName } from '../plugins/registry.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 
 const directRouteDisabledTools = new Set(['run_subagent'])
@@ -17,7 +19,9 @@ export async function handleGetTools(_req, res) {
     projectSkillNames: activeProject?.skills,
     workspaceRoot: activeProject?.path,
   })
-  sendJson(res, 200, { tools: [...skillTools, ...workspaceTools] })
+  const pluginTools = await createPluginToolDefinitions(activeProject ? { workspaceRoot: activeProject.path, project: activeProject } : null)
+  const mcpTools = await createMcpToolDefinitions()
+  sendJson(res, 200, { tools: [...skillTools, ...workspaceTools, ...mcpTools, ...pluginTools] })
 }
 
 const workspaceToolNames = new Set(workspaceTools.map((tool) => tool.name))
@@ -69,6 +73,13 @@ export async function handleToolApi(req, res, url) {
     name = decodeSegment(parts[4])
   }
 
+  if (isPluginToolName(name)) {
+    const params = await readJsonBody(req)
+    const result = await callPluginTool(name, params || {}, context)
+    sendJson(res, 200, result)
+    return
+  }
+
   const handler = toolHandlers[name]
   if (!handler || directRouteDisabledTools.has(name)) {
     const error = new Error(`Unknown tool: ${name}`)

package/server/skills.mjs

@@ -2,9 +2,12 @@ import { existsSync, promises as fs } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { dataDir } from './storage.mjs'
+import { getEnabledPluginSkillSources } from './plugins/registry.mjs'
 
 const userSkillsDir = path.join(dataDir, 'skills')
 const sharedUserSkillsDir = path.join(os.homedir(), '.agents', 'skills')
+const claudeUserSkillsDir = path.join(os.homedir(), '.claude', 'skills')
+const opencodeUserSkillsDir = path.join(os.homedir(), '.opencode', 'skills')
 const defaultEntry = 'SKILL.md'
 const resourceDirs = ['scripts', 'references', 'assets']
 const maxResourceFiles = 200
@@ -312,6 +315,14 @@ function projectSharedSkillsDir(workspaceRoot) {
   return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.agents', 'skills') : ''
 }
 
+function projectClaudeSkillsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.claude', 'skills') : ''
+}
+
+function projectOpencodeSkillsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.opencode', 'skills') : ''
+}
+
 async function loadSkillsFromSources(sources) {
   const skillsByName = new Map()
 
@@ -335,6 +346,30 @@ async function loadSkillsFromSources(sources) {
   })
 }
 
+async function loadSkillsFromExplicitSources(sources) {
+  const skillsByName = new Map()
+
+  for (const source of sources) {
+    const candidateDirs = [source.dir, ...(await listSkillDirectories(source.dir))]
+    for (const skillDir of candidateDirs) {
+      try {
+        const skill = await loadSkillDirectory(skillDir, source.name)
+        if (!skill) continue
+        if (skillsByName.has(skill.name)) skillsByName.delete(skill.name)
+        skillsByName.set(skill.name, skill)
+      } catch (error) {
+        console.warn(`Failed to load skill from ${skillDir}:`, error.message || error)
+      }
+    }
+  }
+
+  return [...skillsByName.values()].sort((a, b) => {
+    const left = (a.displayName || a.name).toLowerCase()
+    const right = (b.displayName || b.name).toLowerCase()
+    return left.localeCompare(right)
+  })
+}
+
 function searchDirsForList(value) {
   return value.length === 1 ? value[0] : value.slice()
 }
@@ -372,27 +407,49 @@ export function mergeSkills(...skillLists) {
 }
 
 export const skillSearchPaths = {
-  global: searchDirsForList([sharedUserSkillsDir, userSkillsDir]),
-  project: ['<project>/.agents/skills', '<project>/.quickforge/skills'],
+  global: searchDirsForList([claudeUserSkillsDir, opencodeUserSkillsDir, sharedUserSkillsDir, userSkillsDir]),
+  project: ['<project>/.claude/skills', '<project>/.opencode/skills', '<project>/.agents/skills', '<project>/.quickforge/skills'],
 }
 
 export function projectSkillSearchPaths(workspaceRoot) {
   if (!workspaceRoot) return skillSearchPaths.project.slice()
-  return searchDirsForList([projectSharedSkillsDir(workspaceRoot), projectClientSkillsDir(workspaceRoot)])
+  return searchDirsForList([
+    projectClaudeSkillsDir(workspaceRoot),
+    projectOpencodeSkillsDir(workspaceRoot),
+    projectSharedSkillsDir(workspaceRoot),
+    projectClientSkillsDir(workspaceRoot),
+    '<enabled-plugin>/skills',
+  ])
+}
+
+async function loadPluginSkills(workspaceRoot) {
+  if (!workspaceRoot) return []
+  const sources = await getEnabledPluginSkillSources({ workspaceRoot })
+  return loadSkillsFromExplicitSources(sources.map((source) => ({ dir: source.dir, name: source.source })))
 }
 
 export async function loadGlobalSkills() {
   return loadSkillsFromSources([
+    { dir: claudeUserSkillsDir, name: 'user-claude' },
+    { dir: opencodeUserSkillsDir, name: 'user-opencode' },
     { dir: sharedUserSkillsDir, name: 'user-shared' },
     { dir: userSkillsDir, name: 'user' },
   ])
 }
 
 export async function loadProjectSkills(workspaceRoot) {
-  return loadSkillsFromSources([
+  const pluginSkills = await loadPluginSkills(workspaceRoot)
+  const projectSkills = await loadSkillsFromSources([
+    { dir: projectClaudeSkillsDir(workspaceRoot), name: 'project-claude' },
+    { dir: projectOpencodeSkillsDir(workspaceRoot), name: 'project-opencode' },
     { dir: projectSharedSkillsDir(workspaceRoot), name: 'project-shared' },
     { dir: projectClientSkillsDir(workspaceRoot), name: 'project' },
   ])
+  return mergeSkills(projectSkills, pluginSkills).sort((a, b) => {
+    const left = (a.displayName || a.name).toLowerCase()
+    const right = (b.displayName || b.name).toLowerCase()
+    return left.localeCompare(right)
+  })
 }
 
 export async function loadSkills() {
@@ -442,7 +499,9 @@ export async function loadSelectedGlobalSkills(skillNames) {
 }
 
 export async function loadSelectedProjectSkills(skillNames, workspaceRoot) {
-  return selectSkills(skillNames, await loadProjectSkills(workspaceRoot))
+  const skills = await loadProjectSkills(workspaceRoot)
+  const pluginSkills = skills.filter((skill) => String(skill.source || '').startsWith('plugin:'))
+  return mergeSkills(pluginSkills, selectSkills(skillNames, skills))
 }
 
 export async function loadSelectedSkills(skillNames) {

package/server/storage.mjs

@@ -48,6 +48,7 @@ export const stores = new Set([
   'settings',
   'provider-keys',
   'custom-providers',
+  'plugins',
   'sessions',
   'sessions-metadata',
   'scheduled-tasks',
@@ -73,13 +74,14 @@ export function getStoreRevision(storeName) {
   return storeRevisions.get(storeName) || 0
 }
 
-const configStores = new Set(['settings', 'provider-keys', 'custom-providers'])
+const configStores = new Set(['settings', 'provider-keys', 'custom-providers', 'plugins'])
 const sessionStores = new Set(['sessions', 'sessions-metadata'])
 
 const configStoreSections = {
   settings: ['app', 'settings'],
   'provider-keys': ['credentials', 'providerKeys'],
   'custom-providers': ['providers', 'customProviders'],
+  plugins: ['extensions', 'plugins'],
 }
 
 export function getDataDir() {
@@ -107,11 +109,6 @@ export function configFile() {
   return quickForgeConfigFile
 }
 
-// Compatibility export for older modules/imports. Project config now lives inside config/config.json -> projects.
-export function projectConfigFile() {
-  return quickForgeConfigFile
-}
-
 function legacyFlatStoreFile(storeName) {
   return path.join(storageDir, `${storeName}.json`)
 }
@@ -154,6 +151,9 @@ function defaultConfig() {
     credentials: {
       providerKeys: {},
     },
+    extensions: {
+      plugins: {},
+    },
     projects: defaultProjectConfig(),
   }
 }
@@ -217,6 +217,13 @@ function normalizeConfig(value) {
           ? input.credentials.providerKeys
           : base.credentials.providerKeys,
     },
+    extensions: {
+      ...(input.extensions && typeof input.extensions === 'object' ? input.extensions : {}),
+      plugins:
+        input.extensions?.plugins && typeof input.extensions.plugins === 'object'
+          ? input.extensions.plugins
+          : base.extensions.plugins,
+    },
     projects: normalizeProjectConfig(input.projects),
   }
 }

package/server/system-prompt.mjs

@@ -27,6 +27,10 @@ function escapeXml(value) {
     .replace(/>/g, '>')
 }
 
+function escapeAttribute(value) {
+  return escapeXml(value).replace(/"/g, '"')
+}
+
 function formatAllowedTools(value) {
   if (Array.isArray(value)) return value.join(', ')
   return value
@@ -83,6 +87,22 @@ ${skillParts.join('\n')}
 </available_skills>`)
 }
 
+function appendInstructionSources(parts, tagName, sources, fallback) {
+  const instructionSources = Array.isArray(sources)
+    ? sources.filter((source) => source?.content)
+    : []
+
+  if (instructionSources.length > 0) {
+    for (const source of instructionSources) {
+      const sourceAttribute = source.source ? ` source="${escapeAttribute(source.source)}"` : ''
+      parts.push(`\n<${tagName}${sourceAttribute}>\n${source.content}\n</${tagName}>`)
+    }
+    return
+  }
+
+  if (fallback) parts.push(`\n<${tagName}>\n${fallback}\n</${tagName}>`)
+}
+
 export function composeSystemPrompt(instructions = {}) {
   const parts = [BASE_SYSTEM_PROMPT]
 
@@ -103,12 +123,14 @@ ${lines.join('\n')}
     }
   }
 
-  if (instructions.global) {
-    parts.push(`\n<user_instructions>\n${instructions.global}\n</user_instructions>`)
-  }
+  appendInstructionSources(parts, 'user_instructions', instructions.globalSources, instructions.global)
+  appendInstructionSources(parts, 'project_instructions', instructions.projectSources, instructions.project)
 
-  if (instructions.project) {
-    parts.push(`\n<project_instructions>\n${instructions.project}\n</project_instructions>`)
+  if (instructions.globalSources?.length || instructions.projectSources?.length) {
+    parts.push(`
+<instruction_precedence>
+When instructions from different sources conflict, prefer project-specific instructions over global instructions, and prefer QuickForge project instructions over external compatibility instructions.
+</instruction_precedence>`)
   }
 
   const skills = Array.isArray(instructions.skills)

package/server/tool-wiring.mjs

@@ -7,6 +7,7 @@
 
 import { toolHandlers } from './tools/index.mjs'
 import { callMcpTool } from './mcp/registry.mjs'
+import { callPluginTool } from './plugins/registry.mjs'
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -75,6 +76,31 @@ export function wrapMcpToolDefinition(definition, toolPermissions) {
   }
 }
 
+export function wrapPluginToolDefinition(definition, context, toolPermissions) {
+  return {
+    ...definition,
+    execute: async (_toolCallId, params, signal, onUpdate) => {
+      if (toolPermissions) {
+        const permissionError = toolPermissions(definition.name)
+        if (permissionError) throw new Error(permissionError)
+      }
+
+      const startedAt = Date.now()
+      const startedAtPerf = performance.now()
+      const result = await callPluginTool(definition.name, params || {}, { ...context, signal, onUpdate, toolCallId: _toolCallId })
+      const finishedAt = Date.now()
+      const durationMs = Math.max(0, Math.round(performance.now() - startedAtPerf))
+      if (result.isError) {
+        throw new Error(result.content || `Plugin tool failed: ${definition.name}`)
+      }
+      return {
+        content: [{ type: 'text', text: result.content }],
+        details: mergeQuickForgeTiming(result.details, { startedAt, finishedAt, durationMs }),
+      }
+    },
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Skill context
 // ---------------------------------------------------------------------------