@shawnstack/quickforge 1.3.24 → 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/session-utils.mjs

@@ -1,4 +1,4 @@
-import { streamSimple } from '@mariozechner/pi-ai'
+import { streamSimple } from '@earendil-works/pi-ai'
 import { buildInstructionsPayload } from './project-config.mjs'
 import { composeSystemPrompt } from './system-prompt.mjs'
 import { listSubagentProfiles } from './agent-profiles.mjs'

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',
@@ -62,13 +63,25 @@ export const stores = new Set([
 const sessionBucketIndex = new Map()
 let bucketIndexBuilt = false
 
-const configStores = new Set(['settings', 'provider-keys', 'custom-providers'])
+// Monotonic in-process revisions for cache invalidation in route-level indexes.
+const storeRevisions = new Map()
+
+function bumpStoreRevision(storeName) {
+  storeRevisions.set(storeName, (storeRevisions.get(storeName) || 0) + 1)
+}
+
+export function getStoreRevision(storeName) {
+  return storeRevisions.get(storeName) || 0
+}
+
+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() {
@@ -96,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`)
 }
@@ -143,6 +151,9 @@ function defaultConfig() {
     credentials: {
       providerKeys: {},
     },
+    extensions: {
+      plugins: {},
+    },
     projects: defaultProjectConfig(),
   }
 }
@@ -206,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),
   }
 }
@@ -370,6 +388,34 @@ async function readAllSessionValues() {
   return result
 }
 
+function sessionMetadataQueueName(bucket) {
+  return bucket.scope === 'project' ? `sessions-metadata:${bucket.projectId}` : 'sessions-metadata:global'
+}
+
+function sameSessionBucket(left, right) {
+  if (!left || !right) return false
+  return left.scope === right.scope && (left.projectId || undefined) === (right.projectId || undefined)
+}
+
+function updateSessionMetadataBucketIndex(bucket, previousData, nextData) {
+  const ids = new Set([
+    ...Object.keys(previousData || {}),
+    ...Object.keys(nextData || {}),
+  ])
+
+  for (const sessionId of ids) {
+    const meta = nextData?.[sessionId]
+    if (meta && typeof meta === 'object') {
+      sessionBucketIndex.set(sessionId, sessionBucket(meta))
+      continue
+    }
+
+    if (sameSessionBucket(sessionBucketIndex.get(sessionId), bucket)) {
+      sessionBucketIndex.delete(sessionId)
+    }
+  }
+}
+
 async function writeSessionValueFile(sessionId, value) {
   await writeJsonAtomic(sessionDataFile(sessionId, sessionBucket(value)), value)
   // Keep in-memory index current
@@ -497,6 +543,15 @@ async function writeSessionStore(storeName, data) {
     filesToWrite.add(sessionStoreFile(storeName, bucket))
   }
 
+  const previousByFile = new Map()
+  if (storeName === 'sessions-metadata') {
+    await Promise.all(
+      [...filesToWrite].map(async (file) => {
+        previousByFile.set(file, await readJsonFile(file, {}))
+      }),
+    )
+  }
+
   await Promise.all(
     [...filesToWrite].map(async (file) => {
       const bucketEntry = [...buckets.values()].find((entry) => sessionStoreFile(storeName, entry.bucket) === file)
@@ -506,9 +561,14 @@ async function writeSessionStore(storeName, data) {
 
   // Keep in-memory bucket index current for metadata writes
   if (storeName === 'sessions-metadata') {
-    for (const [sessionId, meta] of Object.entries(data || {})) {
-      if (meta && typeof meta === 'object') sessionBucketIndex.set(sessionId, sessionBucket(meta))
+    for (const file of filesToWrite) {
+      const bucketEntry = [...buckets.values()].find((entry) => sessionStoreFile(storeName, entry.bucket) === file)
+      const bucket = bucketEntry?.bucket ?? (file === sessionStoreFile(storeName, { scope: 'global' })
+        ? { scope: 'global' }
+        : { scope: 'project', projectId: path.basename(path.dirname(file)) })
+      updateSessionMetadataBucketIndex(bucket, previousByFile.get(file) ?? {}, bucketEntry?.data ?? {})
     }
+    bumpStoreRevision(storeName)
   }
 }
 
@@ -607,6 +667,29 @@ export async function atomicUpdate(storeName, updateFn) {
   })
 }
 
+/**
+ * Atomically read-modify-write the scoped sessions metadata file within its serialized write queue.
+ *
+ * @param {string} scope
+ * @param {string|null|undefined} projectId
+ * @param {(data: object) => object} updateFn — receives current scoped metadata, returns updated metadata
+ * @returns {Promise<object>} the updated scoped metadata
+ */
+export async function atomicSessionMetadataUpdate(scope, projectId, updateFn) {
+  const bucket = scope === 'project' ? { scope: 'project', projectId } : { scope: 'global' }
+  const file = sessionStoreFile('sessions-metadata', bucket)
+  return enqueueWrite(sessionMetadataQueueName(bucket), async () => {
+    await ensureStorage()
+    const data = await readJsonFile(file, {})
+    const previousData = { ...data }
+    const updated = updateFn(data)
+    await writeJsonAtomic(file, updated)
+    updateSessionMetadataBucketIndex(bucket, previousData, updated)
+    bumpStoreRevision('sessions-metadata')
+    return updated
+  })
+}
+
 /**
  * Atomically read-modify-write the project config within the config queue.
  */

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

@@ -0,0 +1,113 @@
+/**
+ * Tool definition wrapping and execution wiring.
+ *
+ * Wraps raw tool definitions with execution handlers that inject
+ * timing metadata, permission checks, and context.
+ */
+
+import { toolHandlers } from './tools/index.mjs'
+import { callMcpTool } from './mcp/registry.mjs'
+import { callPluginTool } from './plugins/registry.mjs'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+export function mergeQuickForgeTiming(details, timing) {
+  if (!isPlainObject(details)) return { quickforgeTiming: timing }
+  return { ...details, quickforgeTiming: timing }
+}
+
+// ---------------------------------------------------------------------------
+// Tool wrappers
+// ---------------------------------------------------------------------------
+
+export function wrapToolDefinition(definition, context, toolPermissions) {
+  const handler = toolHandlers[definition.name]
+  if (!handler) throw new Error(`Missing handler for tool: ${definition.name}`)
+  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 handler(params || {}, context, { signal, onUpdate, toolCallId: _toolCallId })
+      const finishedAt = Date.now()
+      const durationMs = Math.max(0, Math.round(performance.now() - startedAtPerf))
+      const details = mergeQuickForgeTiming(result.details, { startedAt, finishedAt, durationMs })
+      return {
+        content: [{ type: 'text', text: result.content }],
+        details: isPlainObject(details) ? { ...details, toolCallId: _toolCallId } : details,
+      }
+    },
+  }
+}
+
+export function wrapMcpToolDefinition(definition, toolPermissions) {
+  return {
+    ...definition,
+    execute: async (_toolCallId, params) => {
+      if (toolPermissions) {
+        const permissionError = toolPermissions(definition.name)
+        if (permissionError) throw new Error(permissionError)
+      }
+
+      const startedAt = Date.now()
+      const startedAtPerf = performance.now()
+      const result = await callMcpTool(definition.name, params || {})
+      const finishedAt = Date.now()
+      const durationMs = Math.max(0, Math.round(performance.now() - startedAtPerf))
+      if (result.isError) {
+        throw new Error(result.content || `MCP tool failed: ${definition.name}`)
+      }
+      return {
+        content: [{ type: 'text', text: result.content }],
+        details: mergeQuickForgeTiming(result.details, { startedAt, finishedAt, durationMs }),
+      }
+    },
+  }
+}
+
+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
+// ---------------------------------------------------------------------------
+
+export function sessionSkillsContext(session) {
+  return {
+    globalSkillNames: session.globalSkillNames,
+    projectSkillNames: session.projectSkillNames,
+  }
+}

package/server/utils/workspace.mjs

@@ -131,21 +131,40 @@ export async function assertDirectory(dir) {
   }
 }
 
+const SIZE_SKIP_DIRS = new Set(['.git', 'node_modules', 'dist', 'dist-ssr', '.vite', '.cache', '.next', '.nuxt', '__pycache__', '.venv', 'venv'])
+const directorySizeCache = new Map()
+const DIRECTORY_SIZE_CACHE_TTL_MS = 10_000
+
 export async function directorySize(dir) {
   try {
+    const now = Date.now()
+    const cached = directorySizeCache.get(dir)
+    if (cached && now - cached.ts < DIRECTORY_SIZE_CACHE_TTL_MS) return cached.size
+
     const entries = await fs.readdir(dir, { withFileTypes: true })
     const sizes = await Promise.all(entries.map(async (entry) => {
+      if (entry.isDirectory() && SIZE_SKIP_DIRS.has(entry.name)) return 0
       const full = path.join(dir, entry.name)
       if (entry.isDirectory()) return directorySize(full)
       const stat = await fs.stat(full)
       return stat.size
     }))
-    return sizes.reduce((sum, value) => sum + value, 0)
+    const size = sizes.reduce((sum, value) => sum + value, 0)
+    directorySizeCache.set(dir, { size, ts: now })
+    return size
   } catch {
     return 0
   }
 }
 
+export function invalidateDirectorySizeCache(dir) {
+  if (dir) {
+    directorySizeCache.delete(dir)
+  } else {
+    directorySizeCache.clear()
+  }
+}
+
 export function shouldSkipSearchDir(name) {
   return ['.git', 'node_modules', 'dist', 'dist-ssr', '.vite'].includes(name)
 }