@shawnstack/quickforge 1.1.0 → 1.2.1

package/server/storage.mjs

@@ -8,8 +8,17 @@ export const stores = new Set([
   'custom-providers',
   'sessions',
   'sessions-metadata',
+  'scheduled-tasks',
 ])
 
+// --- In-memory session bucket index ---
+// Avoids O(n) directory scanning in findSessionBucket() by caching
+// sessionId → { scope, projectId } lookups.  Populated lazily on first
+// lookup and kept up-to-date by write/delete paths.
+/** @type {Map<string, { scope: string, projectId?: string }>} */
+const sessionBucketIndex = new Map()
+let bucketIndexBuilt = false
+
 const configStores = new Set(['settings', 'provider-keys', 'custom-providers'])
 const sessionStores = new Set(['sessions', 'sessions-metadata'])
 
@@ -73,6 +82,7 @@ function legacyNestedProjectConfigFile() {
 function defaultProjectConfig() {
   return {
     activeProjectId: null,
+    globalSkills: [],
     projects: [],
   }
 }
@@ -94,11 +104,33 @@ function defaultConfig() {
   }
 }
 
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return []
+  const result = []
+  const seen = new Set()
+  for (const item of value) {
+    if (typeof item !== 'string') continue
+    const text = item.trim()
+    if (!text || seen.has(text)) continue
+    seen.add(text)
+    result.push(text)
+  }
+  return result
+}
+
 function normalizeProjectConfig(value) {
-  if (!value || typeof value !== 'object' || !Array.isArray(value.projects)) return defaultProjectConfig()
+  const base = defaultProjectConfig()
+  if (!value || typeof value !== 'object') return base
+  const projects = Array.isArray(value.projects)
+    ? value.projects.map((project) => ({
+      ...project,
+      skills: normalizeStringArray(project?.skills),
+    }))
+    : base.projects
   return {
-    activeProjectId: typeof value.activeProjectId === 'string' ? value.activeProjectId : null,
-    projects: value.projects,
+    activeProjectId: typeof value.activeProjectId === 'string' ? value.activeProjectId : base.activeProjectId,
+    globalSkills: normalizeStringArray(value.globalSkills),
+    projects,
   }
 }
 
@@ -169,10 +201,24 @@ function sessionStoreFile(storeName, bucket) {
   return path.join(storageDir, 'conversations', 'global', `${storeName}.json`)
 }
 
+function sessionDataDir(bucket) {
+  if (bucket.scope === 'project') {
+    assertSafePathSegment(bucket.projectId)
+    return path.join(storageDir, 'conversations', 'projects', bucket.projectId, 'sessions')
+  }
+  return path.join(storageDir, 'conversations', 'global', 'sessions')
+}
+
+function sessionDataFile(sessionId, bucket) {
+  assertSafePathSegment(sessionId)
+  return path.join(sessionDataDir(bucket), `${sessionId}.json`)
+}
+
 export async function ensureProjectCache(projectId) {
   const safeProjectId = String(projectId || '')
   assertSafePathSegment(safeProjectId)
   const projectCacheDir = path.join(cacheDir, 'projects', safeProjectId)
+  const projectStorageDir = path.join(storageDir, 'conversations', 'projects', safeProjectId)
 
   await Promise.all([
     fs.mkdir(path.join(projectCacheDir, 'workspace', 'file-index'), { recursive: true }),
@@ -181,6 +227,8 @@ export async function ensureProjectCache(projectId) {
     fs.mkdir(path.join(projectCacheDir, 'llm', 'reasoning'), { recursive: true }),
     fs.mkdir(path.join(projectCacheDir, 'assets'), { recursive: true }),
     fs.mkdir(path.join(projectCacheDir, 'tmp'), { recursive: true }),
+    fs.mkdir(path.join(projectStorageDir, 'sessions'), { recursive: true }),
+    ensureJsonFile(path.join(projectStorageDir, 'sessions-metadata.json')),
   ])
 
   return projectCacheDir
@@ -194,7 +242,8 @@ async function ensureJsonFile(file, defaultValue = {}) {
 async function readJsonFile(file, defaultValue = {}) {
   try {
     const text = await fs.readFile(file, 'utf8')
-    return text.trim() ? JSON.parse(text) : defaultValue
+    const json = text.trimStart()
+    return json ? JSON.parse(json) : defaultValue
   } catch (error) {
     if (error?.code === 'ENOENT') return defaultValue
     throw error
@@ -233,6 +282,132 @@ async function listProjectSessionFiles(storeName) {
     .map((entry) => path.join(projectsDir, entry.name, `${storeName}.json`))
 }
 
+async function listProjectIds() {
+  const projectsDir = path.join(storageDir, 'conversations', 'projects')
+  let entries = []
+  try {
+    entries = await fs.readdir(projectsDir, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  }
+
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+}
+
+async function listSessionDataFiles(bucket) {
+  const dir = sessionDataDir(bucket)
+  let entries = []
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  }
+
+  return entries
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+    .map((entry) => path.join(dir, entry.name))
+}
+
+async function readSessionValuesScoped(scope, projectId) {
+  const bucket = scope === 'project' ? { scope: 'project', projectId } : { scope: 'global' }
+  const files = await listSessionDataFiles(bucket)
+  const result = {}
+  for (const file of files) {
+    const value = await readJsonFile(file, null)
+    if (value?.id) result[value.id] = value
+  }
+  return result
+}
+
+async function readAllSessionValues() {
+  const result = await readSessionValuesScoped('global')
+  for (const projectId of await listProjectIds()) {
+    Object.assign(result, await readSessionValuesScoped('project', projectId))
+  }
+  return result
+}
+
+async function writeSessionValueFile(sessionId, value) {
+  await writeJsonAtomic(sessionDataFile(sessionId, sessionBucket(value)), value)
+  // Keep in-memory index current
+  if (value) sessionBucketIndex.set(sessionId, sessionBucket(value))
+}
+
+async function writeSessionValues(data) {
+  const nextIds = new Set(Object.keys(data || {}))
+  const existingFiles = [
+    ...(await listSessionDataFiles({ scope: 'global' })),
+    ...(await Promise.all(
+      (await listProjectIds()).map((projectId) => listSessionDataFiles({ scope: 'project', projectId })),
+    )).flat(),
+  ]
+
+  await Promise.all(
+    existingFiles.map(async (file) => {
+      const sessionId = path.basename(file, '.json')
+      if (!nextIds.has(sessionId)) {
+        await fs.rm(file, { force: true })
+        sessionBucketIndex.delete(sessionId)
+      }
+    }),
+  )
+
+  await Promise.all(
+    Object.entries(data || {}).map(([sessionId, value]) => writeSessionValueFile(sessionId, value)),
+  )
+}
+
+async function rebuildBucketIndex() {
+  sessionBucketIndex.clear()
+  // Global bucket
+  try {
+    const globalMeta = await readJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' }), {})
+    for (const [id, meta] of Object.entries(globalMeta)) {
+      if (meta && typeof meta === 'object') sessionBucketIndex.set(id, sessionBucket(meta))
+    }
+  } catch { /* ignore */ }
+  // Project buckets
+  for (const projectId of await listProjectIds()) {
+    try {
+      const meta = await readJsonFile(sessionStoreFile('sessions-metadata', { scope: 'project', projectId }), {})
+      for (const [id, entry] of Object.entries(meta)) {
+        if (entry && typeof entry === 'object') sessionBucketIndex.set(id, sessionBucket(entry))
+      }
+    } catch { /* ignore */ }
+  }
+  bucketIndexBuilt = true
+}
+
+export async function findSessionBucket(sessionId) {
+  if (!bucketIndexBuilt) {
+    await ensureStorage()
+    await rebuildBucketIndex()
+  }
+  return sessionBucketIndex.get(sessionId) ?? null
+}
+
+export async function readSessionValue(sessionId) {
+  const bucket = await findSessionBucket(sessionId)
+  if (!bucket) return null
+  return readJsonFile(sessionDataFile(sessionId, bucket), null)
+}
+
+export async function writeSessionValue(sessionId, value) {
+  return enqueueWrite('sessions', async () => {
+    await ensureStorage()
+    await writeSessionValueFile(sessionId, value)
+  })
+}
+
+export async function deleteSessionValue(sessionId) {
+  return enqueueWrite('sessions', async () => {
+    const bucket = await findSessionBucket(sessionId)
+    if (!bucket) return
+    await fs.rm(sessionDataFile(sessionId, bucket), { force: true })
+    sessionBucketIndex.delete(sessionId)
+  })
+}
+
 async function listSessionStoreFiles(storeName) {
   return [
     sessionStoreFile(storeName, { scope: 'global' }),
@@ -241,6 +416,8 @@ async function listSessionStoreFiles(storeName) {
 }
 
 async function readSessionStore(storeName) {
+  if (storeName === 'sessions') return readAllSessionValues()
+
   const files = await listSessionStoreFiles(storeName)
   const result = {}
   for (const file of files) {
@@ -249,7 +426,20 @@ async function readSessionStore(storeName) {
   return result
 }
 
+export async function readSessionStoreScoped(storeName, scope, projectId) {
+  await ensureStorage()
+  if (storeName === 'sessions') return readSessionValuesScoped(scope, projectId)
+
+  const file = sessionStoreFile(storeName, { scope, projectId })
+  return readJsonFile(file, {})
+}
+
 async function writeSessionStore(storeName, data) {
+  if (storeName === 'sessions') {
+    await writeSessionValues(data)
+    return
+  }
+
   const buckets = new Map()
 
   for (const [key, value] of Object.entries(data || {})) {
@@ -270,6 +460,13 @@ async function writeSessionStore(storeName, data) {
       await writeJsonAtomic(file, bucketEntry?.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))
+    }
+  }
 }
 
 async function migrateLegacySessionStore(storeName) {
@@ -318,7 +515,6 @@ async function migrateUnifiedConfig() {
   await writeConfigFile(current)
 
   if (!existsSync(legacyStorageMigrationMarkerFile)) {
-    await migrateLegacySessionStore('sessions')
     await migrateLegacySessionStore('sessions-metadata')
     await fs.mkdir(path.dirname(legacyStorageMigrationMarkerFile), { recursive: true })
     await fs.writeFile(legacyStorageMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
@@ -339,6 +535,50 @@ function enqueueWrite(queueName, operation) {
   return next
 }
 
+/**
+ * Atomically read-modify-write a store within its serialized write queue.
+ * Eliminates the race condition where concurrent read-modify-write operations
+ * from multiple browser tabs would overwrite each other.
+ *
+ * @param {string} storeName
+ * @param {(data: object) => object} updateFn — receives current data, returns updated data
+ * @returns {Promise<object>} the updated data
+ */
+export async function atomicUpdate(storeName, updateFn) {
+  assertStore(storeName)
+  const queueName = configStores.has(storeName) ? 'config' : storeName
+  return enqueueWrite(queueName, async () => {
+    await ensureStorage()
+    if (configStores.has(storeName)) {
+      const config = await readConfigFile()
+      const data = configSection(config, storeName)
+      const updated = updateFn(data)
+      setConfigSection(config, storeName, updated)
+      await writeConfigFile(config)
+      return updated
+    }
+    const data = await readSessionStore(storeName)
+    const updated = updateFn(data)
+    await writeSessionStore(storeName, updated)
+    return updated
+  })
+}
+
+/**
+ * Atomically read-modify-write the project config within the config queue.
+ */
+export async function atomicProjectConfigUpdate(updateFn) {
+  return enqueueWrite('config', async () => {
+    await ensureStorage()
+    const config = await readConfigFile()
+    const projectConfig = normalizeProjectConfig(config.projects)
+    const updated = updateFn(projectConfig)
+    config.projects = normalizeProjectConfig(updated)
+    await writeConfigFile(config)
+    return updated
+  })
+}
+
 export async function ensureStorage() {
   await fs.mkdir(configDir, { recursive: true })
   await fs.mkdir(storageDir, { recursive: true })
@@ -348,6 +588,7 @@ export async function ensureStorage() {
     fs.mkdir(path.join(cacheDir, 'global', 'llm'), { recursive: true }),
     fs.mkdir(path.join(cacheDir, 'global', 'tmp'), { recursive: true }),
     fs.mkdir(path.join(cacheDir, 'projects'), { recursive: true }),
+    fs.mkdir(path.join(storageDir, 'conversations', 'global', 'sessions'), { recursive: true }),
     fs.mkdir(path.join(storageDir, 'conversations', 'projects'), { recursive: true }),
   ])
 
@@ -355,7 +596,7 @@ export async function ensureStorage() {
 
   await Promise.all([
     ensureJsonFile(quickForgeConfigFile, defaultConfig()),
-    ...[...sessionStores].map((store) => ensureJsonFile(sessionStoreFile(store, { scope: 'global' }))),
+    ensureJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' })),
   ])
 }
 

package/server/system-prompt.mjs

@@ -0,0 +1,67 @@
+export const BASE_SYSTEM_PROMPT = `You are a pragmatic coding assistant.
+
+For project tasks:
+- Inspect the workspace before changing files.
+- Make minimal, focused changes.
+- Prefer dedicated workspace tools for reading, editing, and searching files.
+- If dedicated tools are unavailable or insufficient, use the shell/command tool.
+- Use Python through the shell for reliable scripting, data processing, or file transformations.
+- Stay within the current workspace unless the user explicitly asks otherwise.
+- Verify changes with relevant tests, build, lint, or targeted checks.
+- If no suitable tool is available, say so clearly.`
+
+function escapeXml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+function formatSkillCatalogItem(skill) {
+  const details = [
+    `    <name>${escapeXml(skill.name)}</name>`,
+    `    <description>${escapeXml(skill.description)}</description>`,
+  ]
+
+  if (skill.compatibility) details.push(`    <compatibility>${escapeXml(skill.compatibility)}</compatibility>`)
+  if (skill.allowedTools) details.push(`    <allowed_tools>${escapeXml(skill.allowedTools)}</allowed_tools>`)
+
+  return `  <skill>\n${details.join('\n')}\n  </skill>`
+}
+
+function appendSkillsCatalog(parts, skills) {
+  if (!Array.isArray(skills) || skills.length === 0) return
+
+  const skillParts = skills.map(formatSkillCatalogItem)
+  parts.push(`
+<available_skills>
+The following Agent Skills provide specialized instructions for specific tasks. Use progressive disclosure: this catalog is available now, but full skill instructions are loaded only when needed.
+
+When the user's task matches a skill description, call activate_skill with that skill's name before proceeding. If a loaded skill references bundled files under scripts/, references/, or assets/, call read_skill_resource with the skill name and the relative path. Do not assume resources are already loaded.
+
+${skillParts.join('\n')}
+</available_skills>`)
+}
+
+export function composeSystemPrompt(instructions = {}) {
+  const parts = [BASE_SYSTEM_PROMPT]
+
+  if (instructions.global) {
+    parts.push(`\n<user_instructions>\n${instructions.global}\n</user_instructions>`)
+  }
+
+  if (instructions.project) {
+    parts.push(`\n<project_instructions>\n${instructions.project}\n</project_instructions>`)
+  }
+
+  const skills = Array.isArray(instructions.skills)
+    ? instructions.skills
+    : [
+        ...(Array.isArray(instructions.globalSkills) ? instructions.globalSkills : []),
+        ...(Array.isArray(instructions.projectSkills) ? instructions.projectSkills : []),
+      ]
+
+  appendSkillsCatalog(parts, skills)
+
+  return parts.join('\n')
+}

package/server/tools/definitions.mjs

@@ -0,0 +1,120 @@
+import { Type } from 'typebox'
+import { loadSelectedGlobalSkills, loadSelectedProjectSkills, mergeSkills } from '../skills.mjs'
+
+// ---------------------------------------------------------------------------
+// Canonical workspace tool definitions.
+// These are the single source of truth for tool metadata (name, label,
+// description, parameters). Both the server agent-manager (which wraps them
+// with execute handlers) and the GET /api/tools endpoint (which returns them
+// as JSON) import from here.
+//
+// When adding a new tool, add its definition here. The agent-manager connects
+// it to a handler, and the frontend can fetch definitions from /api/tools.
+// ---------------------------------------------------------------------------
+
+export const workspaceTools = [
+  {
+    name: 'get_project_info',
+    label: 'Project info',
+    description: 'Get the project directory bound to this chat.',
+    parameters: Type.Object({}),
+  },
+  {
+    name: 'list_dir',
+    label: 'List directory',
+    description: 'List files and folders inside the project bound to this chat. Paths are relative to that project root.',
+    parameters: Type.Object({
+      path: Type.Optional(Type.String({ description: 'Directory path relative to the workspace root. Defaults to .', default: '.' })),
+    }),
+  },
+  {
+    name: 'read_file',
+    label: 'Read file',
+    description: 'Read a UTF-8 text file inside the project bound to this chat. Use offset and limit for large files.',
+    parameters: Type.Object({
+      path: Type.String({ description: 'File path relative to the workspace root.' }),
+      offset: Type.Optional(Type.Number({ description: '1-based line offset.', default: 1 })),
+      limit: Type.Optional(Type.Number({ description: 'Maximum number of lines to return.', default: 200 })),
+    }),
+  },
+  {
+    name: 'grep_files',
+    label: 'Search files',
+    description: 'Search text in the project files bound to this chat. Returns matching file paths and line numbers.',
+    parameters: Type.Object({
+      query: Type.String({ description: 'Plain text or regular expression to search for.' }),
+      path: Type.Optional(Type.String({ description: 'Directory path relative to the workspace root. Defaults to .', default: '.' })),
+      regex: Type.Optional(Type.Boolean({ description: 'Treat query as a regular expression.', default: false })),
+      caseSensitive: Type.Optional(Type.Boolean({ description: 'Use case-sensitive matching.', default: false })),
+      limit: Type.Optional(Type.Number({ description: 'Maximum matches to return.', default: 200 })),
+    }),
+  },
+  {
+    name: 'write_file',
+    label: 'Write file',
+    description: 'Create or overwrite a UTF-8 text file inside the project bound to this chat.',
+    parameters: Type.Object({
+      path: Type.String({ description: 'File path relative to the workspace root.' }),
+      content: Type.String({ description: 'Complete file content to write.' }),
+    }),
+    executionMode: 'sequential',
+  },
+  {
+    name: 'edit_file',
+    label: 'Edit file',
+    description: 'Edit a text file in the project bound to this chat by replacing exact text. oldText must match exactly once.',
+    parameters: Type.Object({
+      path: Type.String({ description: 'File path relative to the workspace root.' }),
+      oldText: Type.String({ description: 'Exact existing text to replace. Must be unique in the file.' }),
+      newText: Type.String({ description: 'Replacement text.' }),
+    }),
+    executionMode: 'sequential',
+  },
+  {
+    name: 'run_command',
+    label: 'Run command',
+    description: 'Run a shell command in the project bound to this chat. Use this for lint, build, tests, git status, and diagnostics.',
+    parameters: Type.Object({
+      command: Type.String({ description: 'Command to execute in the workspace.' }),
+      timeoutSeconds: Type.Optional(Type.Number({ description: 'Timeout in seconds. Defaults to 60.', default: 60 })),
+    }),
+    executionMode: 'sequential',
+  },
+]
+
+function activeSkillSchema(skills) {
+  const names = skills.map((skill) => skill.name).filter(Boolean)
+  return names.length ? Type.String({ enum: names }) : Type.String()
+}
+
+export async function createSkillTools(config = {}) {
+  const globalSkills = await loadSelectedGlobalSkills(config.globalSkillNames)
+  const projectSkills = config.workspaceRoot
+    ? await loadSelectedProjectSkills(config.projectSkillNames, config.workspaceRoot)
+    : []
+  const skills = mergeSkills(globalSkills, projectSkills)
+  if (skills.length === 0) return []
+
+  const skillNameSchema = activeSkillSchema(skills)
+  return [
+    {
+      name: 'activate_skill',
+      label: 'Activate skill',
+      description: 'Load the full instructions for an enabled Agent Skill when the current task matches its description.',
+      parameters: Type.Object({
+        name: skillNameSchema,
+      }),
+    },
+    {
+      name: 'read_skill_resource',
+      label: 'Read skill resource',
+      description: 'Read a text resource bundled with an activated Agent Skill. Paths are relative to that skill directory.',
+      parameters: Type.Object({
+        skill: skillNameSchema,
+        path: Type.String({ description: 'Relative path inside the skill directory, for example references/REFERENCE.md or scripts/helper.py.' }),
+        offset: Type.Optional(Type.Number({ description: '1-based line offset.', default: 1 })),
+        limit: Type.Optional(Type.Number({ description: 'Maximum number of lines to return.', default: 200 })),
+      }),
+    },
+  ]
+}