@shawnstack/quickforge 1.4.1 → 1.5.1

package/server/agent-profile-files.mjs

@@ -0,0 +1,179 @@
+import { existsSync, promises as fs } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { dataDir } from './storage.mjs'
+import { firstOptionalBoolean, firstString, parseFrontmatter, splitDelimitedList } from './frontmatter.mjs'
+
+const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000
+const DEFAULT_MAX_TOOL_CALLS = 300
+const nameRegex = /^[a-z][a-z0-9_-]{1,39}$/
+const allowedToolNames = new Set(['read_file', 'grep_files', 'write_file', 'edit_file', 'run_command'])
+
+const toolAliases = new Map([
+  ['Read', 'read_file'],
+  ['Grep', 'grep_files'],
+  ['Bash', 'run_command'],
+  ['Write', 'write_file'],
+  ['Edit', 'edit_file'],
+])
+
+const claudeUserAgentsDir = path.join(os.homedir(), '.claude', 'agents')
+const userAgentsDir = path.join(dataDir, 'agents')
+
+function normalizeString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function normalizeName(value) {
+  const name = normalizeString(value)?.toLowerCase()
+  return name && nameRegex.test(name) ? name : null
+}
+
+function normalizeRuntime(value) {
+  if (value === undefined || value === null || value === '') return DEFAULT_MAX_RUNTIME_MS
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MAX_RUNTIME_MS
+  return Math.min(Math.max(Math.round(parsed), 1000), DEFAULT_MAX_RUNTIME_MS)
+}
+
+function normalizeToolCalls(value) {
+  if (value === undefined || value === null || value === '') return DEFAULT_MAX_TOOL_CALLS
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) return DEFAULT_MAX_TOOL_CALLS
+  return Math.min(parsed, DEFAULT_MAX_TOOL_CALLS)
+}
+
+function normalizeTools(value) {
+  const tools = []
+  const seen = new Set()
+  for (const item of splitDelimitedList(value)) {
+    const mapped = toolAliases.get(item) || item
+    if (!allowedToolNames.has(mapped) || seen.has(mapped)) continue
+    seen.add(mapped)
+    tools.push(mapped)
+  }
+  return tools.length ? tools : ['read_file', 'grep_files']
+}
+
+function hasMutationTool(allowedTools) {
+  return allowedTools.some((toolName) => toolName === 'write_file' || toolName === 'edit_file')
+}
+
+export function agentProfileFromMarkdown(file, text, options = {}) {
+  const parsed = parseFrontmatter(text)
+  if (!parsed.body) return null
+
+  const metadata = parsed.metadata || {}
+  const name = normalizeName(metadata.name) || normalizeName(path.basename(file, '.md'))
+  if (!name) return null
+  if (options.reservedNames?.has(name)) return null
+
+  const allowedTools = normalizeTools(
+    metadata.tools ?? metadata['allowed-tools'] ?? metadata.allowedTools,
+  )
+  const label = firstString(metadata.label, metadata.displayName, metadata.title) || name
+  const enabledAsSubagent = firstOptionalBoolean(
+    metadata['enabled-as-subagent'],
+    metadata.enabled_as_subagent,
+    metadata.enabledAsSubagent,
+  )
+
+  return {
+    id: `${options.idPrefix || 'file'}:${name}`,
+    name,
+    label: label.slice(0, 80),
+    description: String(firstString(metadata.description) || '').slice(0, 500),
+    systemPrompt: parsed.body,
+    allowedTools,
+    maxRuntimeMs: normalizeRuntime(metadata['max-runtime-ms'] ?? metadata.max_runtime_ms ?? metadata.maxRuntimeMs),
+    maxToolCalls: normalizeToolCalls(metadata['max-tool-calls'] ?? metadata.max_tool_calls ?? metadata.maxToolCalls),
+    enabledAsSubagent: enabledAsSubagent === undefined ? true : enabledAsSubagent,
+    builtin: false,
+    source: options.source || 'file',
+    readonly: true,
+    filePath: file,
+    relativePath: options.relativePath || path.basename(file),
+    allowFileMutations: hasMutationTool(allowedTools),
+    createdAt: 'file',
+    updatedAt: 'file',
+  }
+}
+
+async function listAgentFilesFromDirectory(dir, options = {}) {
+  if (!dir || !existsSync(dir)) return []
+  let entries
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR' || error?.code === 'EACCES' || error?.code === 'EPERM') return []
+    throw error
+  }
+
+  const profiles = []
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue
+    const file = path.join(dir, entry.name)
+    try {
+      const relativePath = options.relativeRoot
+        ? `${options.relativeRoot}/${entry.name}`.replace(/\\/g, '/')
+        : entry.name
+      const profile = agentProfileFromMarkdown(file, await fs.readFile(file, 'utf8'), {
+        ...options,
+        relativePath,
+      })
+      if (profile) profiles.push(profile)
+    } catch (error) {
+      console.warn(`Failed to load agent profile ${file}:`, error.message || error)
+    }
+  }
+  return profiles
+}
+
+function projectClaudeAgentsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.claude', 'agents') : ''
+}
+
+function projectQuickForgeAgentsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.quickforge', 'agents') : ''
+}
+
+export async function loadUserAgentProfiles(options = {}) {
+  const byName = new Map()
+  const sources = [
+    { dir: claudeUserAgentsDir, source: 'user-claude', relativeRoot: '~/.claude/agents', idPrefix: 'user-claude' },
+    { dir: userAgentsDir, source: 'user', relativeRoot: '~/.quickforge/agents', idPrefix: 'user' },
+  ]
+  for (const source of sources) {
+    for (const profile of await listAgentFilesFromDirectory(source.dir, { ...options, ...source })) {
+      byName.set(profile.name, profile)
+    }
+  }
+  return [...byName.values()]
+}
+
+export async function loadProjectAgentProfiles(workspaceRoot, options = {}) {
+  if (!workspaceRoot) return []
+  const byName = new Map()
+  const sources = [
+    { dir: projectClaudeAgentsDir(workspaceRoot), source: 'project-claude', relativeRoot: '.claude/agents', idPrefix: 'project-claude' },
+    { dir: projectQuickForgeAgentsDir(workspaceRoot), source: 'project', relativeRoot: '.quickforge/agents', idPrefix: 'project' },
+  ]
+  for (const source of sources) {
+    for (const profile of await listAgentFilesFromDirectory(source.dir, { ...options, ...source })) {
+      byName.set(profile.name, profile)
+    }
+  }
+  return [...byName.values()]
+}
+
+export async function loadFileAgentProfiles(workspaceRoot, options = {}) {
+  const byName = new Map()
+  for (const profile of await loadUserAgentProfiles(options)) byName.set(profile.name, profile)
+  for (const profile of await loadProjectAgentProfiles(workspaceRoot, options)) byName.set(profile.name, profile)
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name))
+}
+
+export const agentProfileSearchPaths = {
+  global: ['~/.claude/agents', '~/.quickforge/agents'],
+  project: ['<project>/.claude/agents', '<project>/.quickforge/agents'],
+}

package/server/agent-profiles.mjs

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto'
 import { readStore, atomicUpdate } from './storage.mjs'
 import { subagentDefinitions } from './subagents.mjs'
 import { workspaceTools } from './tools/definitions.mjs'
+import { defaultGlobalWorkspaceContext, projectContextFromId } from './project-config.mjs'
+import { loadFileAgentProfiles } from './agent-profile-files.mjs'
 
 const STORE = 'custom-agents'
 const RESERVED_NAMES = new Set(subagentDefinitions.map((definition) => definition.name))
@@ -56,6 +58,9 @@ function builtinProfileFromSubagent(definition) {
     maxToolCalls: definition.maxToolCalls || DEFAULT_MAX_TOOL_CALLS,
     enabledAsSubagent: true,
     builtin: true,
+    source: 'builtin',
+    readonly: true,
+    allowFileMutations: definition.allowFileMutations === true,
     createdAt: 'builtin',
     updatedAt: 'builtin',
   }
@@ -92,6 +97,9 @@ function normalizeProfileInput(input, existing = null, { creating = false } = {}
     maxToolCalls: normalizeOptionalPositiveInteger(input?.maxToolCalls ?? existing?.maxToolCalls, DEFAULT_MAX_TOOL_CALLS, 300),
     enabledAsSubagent: input?.enabledAsSubagent === undefined ? Boolean(existing?.enabledAsSubagent ?? true) : input.enabledAsSubagent === true,
     builtin: false,
+    source: 'store',
+    readonly: false,
+    allowFileMutations: allowedTools.some((toolName) => toolName === 'write_file' || toolName === 'edit_file'),
     createdAt: existing?.createdAt || now,
     updatedAt: now,
   }
@@ -102,20 +110,61 @@ async function readCustomAgentMap() {
   return data && typeof data === 'object' ? data : {}
 }
 
+async function resolveWorkspaceRoot(options = {}) {
+  if (options.workspaceRoot) return options.workspaceRoot
+  if (options.projectId) {
+    try {
+      return (await projectContextFromId(options.projectId))?.workspaceRoot || null
+    } catch {
+      return null
+    }
+  }
+  return defaultGlobalWorkspaceContext()?.workspaceRoot || null
+}
+
+function mergeProfiles({ builtin = [], file = [], custom = [] }) {
+  const reservedNames = new Set(builtin.map((profile) => profile.name))
+  const byName = new Map()
+
+  for (const profile of builtin) {
+    byName.set(profile.name, profile)
+  }
+  for (const profile of file) {
+    if (!profile?.name || reservedNames.has(profile.name)) continue
+    byName.set(profile.name, profile)
+  }
+  for (const profile of custom) {
+    if (!profile?.id) continue
+    if (!reservedNames.has(profile.name) && !byName.has(profile.name)) byName.set(profile.name, profile)
+  }
+
+  return [...byName.values()].sort((a, b) => {
+    if (a.builtin && !b.builtin) return -1
+    if (!a.builtin && b.builtin) return 1
+    return a.name.localeCompare(b.name)
+  })
+}
+
 export async function listAgentProfiles(options = {}) {
   const custom = Object.values(await readCustomAgentMap())
-  const profiles = [...listBuiltinAgentProfiles(), ...custom]
+  const workspaceRoot = await resolveWorkspaceRoot(options)
+  const file = await loadFileAgentProfiles(workspaceRoot, { reservedNames: RESERVED_NAMES })
+  const profiles = mergeProfiles({ builtin: listBuiltinAgentProfiles(), file, custom })
   return options.includeDisabled ? profiles : profiles.filter((profile) => profile.enabledAsSubagent || profile.builtin || profile.enabledAsSubagent === false)
 }
 
-export async function listSubagentProfiles() {
-  return (await listAgentProfiles({ includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
+export async function listSubagentProfiles(options = {}) {
+  return (await listAgentProfiles({ ...options, includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
 }
 
-export async function getAgentProfile(idOrName) {
+export async function getAgentProfile(idOrName, options = {}) {
   const key = String(idOrName || '').trim().toLowerCase()
   if (!key) return null
-  return (await listAgentProfiles({ includeDisabled: true })).find((profile) => profile.id === key || profile.name === key) || null
+  const profiles = await listAgentProfiles({ ...options, includeDisabled: true })
+  const byName = profiles.find((profile) => profile.name === key)
+  if (byName) return byName
+  const custom = Object.values(await readCustomAgentMap())
+  return custom.find((profile) => profile?.id === key) || profiles.find((profile) => profile.id === key) || null
 }
 
 export async function createCustomAgentProfile(input) {
@@ -167,7 +216,12 @@ export function agentProfileSnapshot(profile) {
     allowedTools: [...profile.allowedTools],
     maxRuntimeMs: profile.maxRuntimeMs,
     maxToolCalls: profile.maxToolCalls,
+    enabledAsSubagent: profile.enabledAsSubagent === true,
     builtin: profile.builtin === true,
+    source: profile.source || (profile.builtin ? 'builtin' : 'store'),
+    readonly: profile.readonly === true || profile.builtin === true,
+    filePath: profile.filePath,
+    relativePath: profile.relativePath,
   }
 }
 

package/server/auto-compaction.mjs

@@ -151,6 +151,76 @@ export function buildAutoCompactLoopMessages(session, messages) {
   return [summaryMessage, ...source.slice(compactedUpToIndex)]
 }
 
+export async function compactSessionInPlace({
+  session,
+  messages,
+  keepRecentTurns = DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns,
+  minSourceChars = DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars,
+  usage,
+  thresholdPercent,
+  emitSessionEvent,
+  persistSession,
+  reason = 'manual_compact',
+  summaryIntro = 'The previous conversation has been compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+  onBeforePersist,
+}) {
+  const source = Array.isArray(messages) ? messages : []
+  const normalizedKeepRecentTurns = clampNumber(keepRecentTurns, DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns, 1, 20)
+  const normalizedMinSourceChars = clampNumber(minSourceChars, DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars, 0, 200000)
+  const tailStart = tailStartForRecentTurns(source, normalizedKeepRecentTurns)
+  const sourceMessages = buildCompactionSourceMessages(session, source, tailStart)
+  if (sourceMessages.length < 2 || estimateMessagesChars(sourceMessages) < normalizedMinSourceChars) {
+    return { compacted: false, usage, reason: 'not_enough_history' }
+  }
+
+  const result = await compactConversation({
+    messages: sourceMessages,
+    model: session.model,
+    thinkingLevel: session.thinkingLevel,
+    getApiKey: session.getApiKey,
+    keepTurns: 0,
+  })
+
+  if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
+
+  await saveCompactBackup(session.sessionId, sourceMessages)
+  const summaryMessage = userTextMessage([
+    summaryIntro,
+    '',
+    '<compact_summary>',
+    result.summary,
+    '</compact_summary>',
+  ].join('\n'))
+  session.contextCompaction = {
+    summaryMessage,
+    compactedUpToIndex: tailStart,
+    compactedAt: new Date().toISOString(),
+    keepRecentTurns: normalizedKeepRecentTurns,
+    sourceMessageCount: source.length,
+    usageBefore: usage,
+    thresholdPercent,
+  }
+  onBeforePersist?.({ result, sourceMessages, tailStart, summaryMessage })
+  await persistSession?.(session)
+  const contextUsage = estimateSessionContextUsage(session, source)
+  emitSessionEvent?.(session, {
+    type: 'auto_compact_completed',
+    reason,
+    usage,
+    thresholdPercent,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  emitSessionEvent?.(session, {
+    type: 'messages_replaced',
+    reason,
+    messages: source,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  return { compacted: true, usage, result, sourceMessages, tailStart }
+}
+
 export function estimateSessionContextUsage(session, messages = session?.agent?.state?.messages ?? []) {
   if (!session?.agent?.state) return null
   const sourceMessages = Array.isArray(messages) ? messages : []
@@ -274,50 +344,23 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
 
   session.autoCompacting = true
   try {
-    const result = await compactConversation({
-      messages: sourceMessages,
-      model: session.model,
-      thinkingLevel: session.thinkingLevel,
-      getApiKey: session.getApiKey,
-      keepTurns: 0,
-    })
-
-    if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
-
-    await saveCompactBackup(session.sessionId, sourceMessages)
-    const summaryMessage = userTextMessage([
-      'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
-      '',
-      '<compact_summary>',
-      result.summary,
-      '</compact_summary>',
-    ].join('\n'))
-    session.contextCompaction = {
-      summaryMessage,
-      compactedUpToIndex: tailStart,
-      compactedAt: new Date().toISOString(),
+    const result = await compactSessionInPlace({
+      session,
+      messages,
       keepRecentTurns: settings.keepRecentTurns,
-      sourceMessageCount: messages.length,
-      usageBefore: usage,
-      thresholdPercent: settings.thresholdPercent,
-    }
-    clearAutoCompactRejected(session)
-    session.lastAutoCompactAt = now
-    await persistSession(session)
-    emitSessionEvent(session, {
-      type: 'auto_compact_completed',
+      minSourceChars: settings.minSourceChars,
       usage,
       thresholdPercent: settings.thresholdPercent,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
-    })
-    emitSessionEvent(session, {
-      type: 'messages_replaced',
+      emitSessionEvent,
+      persistSession,
       reason: 'auto_compact',
-      messages,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
+      summaryIntro: 'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+      onBeforePersist: () => {
+        clearAutoCompactRejected(session)
+        session.lastAutoCompactAt = now
+      },
     })
+    if (!result.compacted) return result
     return { compacted: true, usage }
   } catch (error) {
     logger?.warn?.(`Auto compact failed for session ${session.sessionId}:`, error?.message || error, { sessionId: session.sessionId })