@shawnstack/quickforge 1.0.0

package/server/routes/storage.mjs

@@ -0,0 +1,97 @@
+import path from 'node:path'
+import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import { readStore, writeStore, getComparable, storageDir } from '../storage.mjs'
+import { directorySize } from '../utils/workspace.mjs'
+
+export async function handleStorageApi(req, res, url) {
+  const parts = url.pathname.split('/').filter(Boolean)
+
+  if (req.method === 'GET' && url.pathname === '/api/storage/quota') {
+    const usage = await directorySize(storageDir)
+    sendJson(res, 200, { usage, quota: 0, percent: 0 })
+    return
+  }
+
+  if (parts[0] !== 'api' || parts[1] !== 'storage') {
+    const error = new Error('Not found')
+    error.statusCode = 404
+    throw error
+  }
+
+  const store = decodeSegment(parts[2])
+
+  if (req.method === 'GET' && parts[3] === 'keys') {
+    const prefix = url.searchParams.get('prefix') || ''
+    const data = await readStore(store)
+    const keys = Object.keys(data).filter((key) => !prefix || key.startsWith(prefix))
+    sendJson(res, 200, { keys })
+    return
+  }
+
+  if (req.method === 'GET' && parts[3] === 'index') {
+    const indexName = decodeSegment(parts[4])
+    const direction = url.searchParams.get('direction') === 'desc' ? 'desc' : 'asc'
+    const data = await readStore(store)
+    const values = Object.values(data)
+    values.sort((a, b) => {
+      const left = getComparable(a, indexName)
+      const right = getComparable(b, indexName)
+      if (left === right) return 0
+      if (left === undefined || left === null) return direction === 'desc' ? 1 : -1
+      if (right === undefined || right === null) return direction === 'desc' ? -1 : 1
+      const result = String(left).localeCompare(String(right))
+      return direction === 'desc' ? -result : result
+    })
+    sendJson(res, 200, { values })
+    return
+  }
+
+  if (req.method === 'DELETE' && parts.length === 3) {
+    await writeStore(store, {})
+    sendJson(res, 200, { ok: true })
+    return
+  }
+
+  if (req.method === 'GET' && parts[3] === 'has') {
+    const key = decodeSegment(parts[4])
+    const data = await readStore(store)
+    sendJson(res, 200, { exists: Object.prototype.hasOwnProperty.call(data, key) })
+    return
+  }
+
+  if (parts[3] === 'key') {
+    const key = decodeSegment(parts[4])
+    if (!key) {
+      const error = new Error('Missing storage key')
+      error.statusCode = 400
+      throw error
+    }
+
+    if (req.method === 'GET') {
+      const data = await readStore(store)
+      sendJson(res, 200, { value: Object.prototype.hasOwnProperty.call(data, key) ? data[key] : null })
+      return
+    }
+
+    if (req.method === 'PUT') {
+      const body = await readJsonBody(req)
+      const data = await readStore(store)
+      data[key] = body?.value
+      await writeStore(store, data)
+      sendJson(res, 200, { ok: true })
+      return
+    }
+
+    if (req.method === 'DELETE') {
+      const data = await readStore(store)
+      delete data[key]
+      await writeStore(store, data)
+      sendJson(res, 200, { ok: true })
+      return
+    }
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}

package/server/routes/tools.mjs

@@ -0,0 +1,31 @@
+import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import { toolHandlers } from '../tools/index.mjs'
+import { projectContextFromId } from '../project-config.mjs'
+
+export async function handleToolApi(req, res, url) {
+  if (req.method !== 'POST') {
+    const error = new Error('Tool endpoints require POST')
+    error.statusCode = 405
+    throw error
+  }
+
+  const parts = url.pathname.split('/').filter(Boolean)
+  let name = decodeSegment(parts[2])
+  let context
+
+  if (parts[1] === 'projects' && parts[3] === 'tools') {
+    context = await projectContextFromId(decodeSegment(parts[2]))
+    name = decodeSegment(parts[4])
+  }
+
+  const handler = toolHandlers[name]
+  if (!handler) {
+    const error = new Error(`Unknown tool: ${name}`)
+    error.statusCode = 404
+    throw error
+  }
+
+  const params = await readJsonBody(req)
+  const result = await handler(params || {}, context)
+  sendJson(res, 200, result)
+}

package/server/storage.mjs

@@ -0,0 +1,217 @@
+import { existsSync, promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+export const stores = new Set([
+  'settings',
+  'provider-keys',
+  'custom-providers',
+  'sessions',
+  'sessions-metadata',
+])
+
+function platformDataDir(appName) {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), appName)
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', appName)
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), appName)
+}
+
+export function getDataDir() {
+  if (process.env.QUICKFORGE_DATA_DIR) return path.resolve(process.env.QUICKFORGE_DATA_DIR)
+  if (process.env.FASTCODE_DATA_DIR) return path.resolve(process.env.FASTCODE_DATA_DIR)
+  return path.join(os.homedir(), '.quickforge')
+}
+
+export const dataDir = getDataDir()
+export const storageDir = path.join(dataDir, 'storage')
+
+export function storeFile(storeName) {
+  return path.join(storageDir, `${storeName}.json`)
+}
+
+export function projectConfigFile() {
+  return path.join(storageDir, 'project.json')
+}
+
+const writeQueues = new Map()
+
+export async function ensureStorage() {
+  await fs.mkdir(storageDir, { recursive: true })
+  await Promise.all(
+    [...stores].map(async (store) => {
+      const file = storeFile(store)
+      if (!existsSync(file)) await fs.writeFile(file, '{}\n', 'utf8')
+    }),
+  )
+}
+
+export async function readStore(storeName) {
+  assertStore(storeName)
+  await ensureStorage()
+  const file = storeFile(storeName)
+  try {
+    const text = await fs.readFile(file, 'utf8')
+    return text.trim() ? JSON.parse(text) : {}
+  } catch (error) {
+    if (error?.code === 'ENOENT') return {}
+    throw error
+  }
+}
+
+export async function writeStore(storeName, data) {
+  assertStore(storeName)
+  const previous = writeQueues.get(storeName) || Promise.resolve()
+  const next = previous
+    .catch(() => undefined)
+    .then(async () => {
+      await ensureStorage()
+      const file = storeFile(storeName)
+      const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
+      await fs.writeFile(tmp, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
+      await fs.rename(tmp, file)
+    })
+  writeQueues.set(storeName, next)
+  return next
+}
+
+function assertStore(storeName) {
+  if (!stores.has(storeName)) {
+    const error = new Error(`Unknown storage store: ${storeName}`)
+    error.statusCode = 404
+    throw error
+  }
+}
+
+export function getComparable(value, key) {
+  if (!value || typeof value !== 'object') return undefined
+  return key.split('.').reduce((current, part) => {
+    if (!current || typeof current !== 'object') return undefined
+    return current[part]
+  }, value)
+}
+
+export async function directoryExists(file) {
+  try {
+    await fs.access(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function readJsonObject(file) {
+  try {
+    const text = await fs.readFile(file, 'utf8')
+    const parsed = text.trim() ? JSON.parse(text) : {}
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+export async function mergeJsonObjectFile(sourceFile, targetFile) {
+  const source = await readJsonObject(sourceFile)
+  if (!source) return false
+
+  const target = (await readJsonObject(targetFile)) ?? {}
+  let changed = false
+  for (const [key, value] of Object.entries(source)) {
+    if (Object.hasOwn(target, key)) continue
+    target[key] = value
+    changed = true
+  }
+
+  if (!changed) return false
+
+  await fs.mkdir(path.dirname(targetFile), { recursive: true })
+  const tmp = `${targetFile}.${process.pid}.${Date.now()}.tmp`
+  await fs.writeFile(tmp, `${JSON.stringify(target, null, 2)}\n`, 'utf8')
+  await fs.rename(tmp, targetFile)
+  return true
+}
+
+export async function copyMissingRecursive(source, target) {
+  const stat = await fs.stat(source).catch(() => null)
+  if (!stat) return false
+
+  if (stat.isDirectory()) {
+    await fs.mkdir(target, { recursive: true })
+    let copied = false
+    const entries = await fs.readdir(source, { withFileTypes: true })
+    for (const entry of entries) {
+      copied = (await copyMissingRecursive(path.join(source, entry.name), path.join(target, entry.name))) || copied
+    }
+    return copied
+  }
+
+  if (!stat.isFile() || (await directoryExists(target))) return false
+
+  await fs.mkdir(path.dirname(target), { recursive: true })
+  await fs.copyFile(source, target)
+  return true
+}
+
+export function uniquePaths(paths) {
+  const seen = new Set()
+  return paths.filter((item) => {
+    const resolved = path.resolve(item)
+    const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+export async function migrateLegacyDataDir(sourceDir) {
+  const resolvedSource = path.resolve(sourceDir)
+  const resolvedTarget = path.resolve(dataDir)
+  const sourceKey = process.platform === 'win32' ? resolvedSource.toLowerCase() : resolvedSource
+  const targetKey = process.platform === 'win32' ? resolvedTarget.toLowerCase() : resolvedTarget
+  if (sourceKey === targetKey) return false
+
+  const sourceStorageDir = path.join(resolvedSource, 'storage')
+  if (!(await directoryExists(sourceStorageDir))) return false
+
+  await fs.mkdir(storageDir, { recursive: true })
+
+  let migrated = false
+  for (const store of stores) {
+    const sourceFile = path.join(sourceStorageDir, `${store}.json`)
+    const targetFile = storeFile(store)
+    if (!(await directoryExists(sourceFile))) continue
+    if (await directoryExists(targetFile)) {
+      migrated = (await mergeJsonObjectFile(sourceFile, targetFile)) || migrated
+    } else {
+      await fs.copyFile(sourceFile, targetFile)
+      migrated = true
+    }
+  }
+
+  const sourceProjectFile = path.join(sourceStorageDir, 'project.json')
+  if ((await directoryExists(sourceProjectFile)) && !(await directoryExists(projectConfigFile()))) {
+    await fs.copyFile(sourceProjectFile, projectConfigFile())
+    migrated = true
+  }
+
+  migrated = (await copyMissingRecursive(sourceStorageDir, storageDir)) || migrated
+  if (migrated) console.log(`Migrated legacy QuickForge data from ${resolvedSource} to ${resolvedTarget}`)
+  return migrated
+}
+
+export async function migrateLegacyDataDirs() {
+  if (process.env.QUICKFORGE_DATA_DIR || process.env.FASTCODE_DATA_DIR) return
+
+  const legacyDirs = uniquePaths([
+    platformDataDir('QuickForge'),
+    platformDataDir('FastCode'),
+    path.join(os.homedir(), '.fastcode'),
+  ])
+
+  for (const dir of legacyDirs) {
+    await migrateLegacyDataDir(dir)
+  }
+}

package/server/tools/index.mjs

@@ -0,0 +1,236 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { resolveWorkspacePath, toWorkspaceRelative, assertSafeWorkspacePath, truncateText, splitLines, shouldSkipSearchDir, shouldSearchFile, isSensitiveWorkspacePath } from '../utils/workspace.mjs'
+import { readProjectConfig, getActiveProject } from '../project-config.mjs'
+import { getWorkspaceRoot, getToolWorkspaceRoot } from '../utils/workspace.mjs'
+
+// --- list_dir ---
+export async function toolListDir(params, context) {
+  const dir = resolveWorkspacePath(params?.path || '.', context)
+  assertSafeWorkspacePath(dir, context)
+
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+  const rows = await Promise.all(entries.map(async (entry) => {
+    const fullPath = path.join(dir, entry.name)
+    const stat = await fs.stat(fullPath).catch(() => null)
+    return {
+      name: `${entry.name}${entry.isDirectory() ? '/' : ''}`,
+      type: entry.isDirectory() ? 'directory' : entry.isFile() ? 'file' : 'other',
+      size: stat?.size ?? 0,
+      modified: stat?.mtime?.toISOString?.() ?? '',
+    }
+  }))
+
+  rows.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+    return a.name.localeCompare(b.name)
+  })
+
+  const content = rows.length
+    ? rows.map((row) => `${row.type.padEnd(9)} ${String(row.size).padStart(10)} ${row.modified} ${row.name}`).join('\n')
+    : '(empty directory)'
+
+  return { content, details: { path: toWorkspaceRelative(dir, context), project: context?.project, count: rows.length } }
+}
+
+// --- read_file ---
+export async function toolReadFile(params, context) {
+  const file = resolveWorkspacePath(params?.path, context)
+  assertSafeWorkspacePath(file, context)
+
+  const text = await fs.readFile(file, 'utf8')
+  const lines = splitLines(text)
+  const offset = Math.max(1, Number(params?.offset || 1))
+  const limit = Math.min(2000, Math.max(1, Number(params?.limit || 200)))
+  const selected = lines.slice(offset - 1, offset - 1 + limit)
+  const content = selected.map((line, index) => `${offset + index}: ${line}`).join('\n')
+  const suffix = offset - 1 + limit < lines.length ? `\n\n[showing ${selected.length} of ${lines.length} lines]` : ''
+
+  return {
+    content: truncateText(`${content}${suffix}`),
+    details: { path: toWorkspaceRelative(file, context), project: context?.project, totalLines: lines.length, offset, limit },
+  }
+}
+
+// --- grep_files ---
+export async function toolGrepFiles(params, context) {
+  const root = resolveWorkspacePath(params?.path || '.', context)
+  assertSafeWorkspacePath(root, context)
+
+  const query = String(params?.query || '')
+  if (!query) {
+    const error = new Error('query is required')
+    error.statusCode = 400
+    throw error
+  }
+
+  const limit = Math.min(1000, Math.max(1, Number(params?.limit || 200)))
+  const flags = params?.caseSensitive ? 'g' : 'gi'
+  const matcher = params?.regex
+    ? new RegExp(query, flags)
+    : new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags)
+
+  const files = await walkFiles(root, [], context)
+  const matches = []
+
+  for (const file of files) {
+    if (matches.length >= limit) break
+    const stat = await fs.stat(file)
+    if (stat.size > 1024 * 1024) continue
+
+    const text = await fs.readFile(file, 'utf8').catch(() => '')
+    const lines = splitLines(text)
+    for (let index = 0; index < lines.length && matches.length < limit; index++) {
+      matcher.lastIndex = 0
+      if (matcher.test(lines[index])) {
+        matches.push(`${toWorkspaceRelative(file, context)}:${index + 1}: ${lines[index]}`)
+      }
+    }
+  }
+
+  return {
+    content: matches.length ? truncateText(matches.join('\n')) : 'No matches found.',
+    details: { path: toWorkspaceRelative(root, context), project: context?.project, query, count: matches.length, limit },
+  }
+}
+
+// --- write_file ---
+export async function toolWriteFile(params, context) {
+  const file = resolveWorkspacePath(params?.path, context)
+  assertSafeWorkspacePath(file, context)
+
+  await fs.mkdir(path.dirname(file), { recursive: true })
+  await fs.writeFile(file, String(params?.content ?? ''), 'utf8')
+
+  return {
+    content: `Wrote ${toWorkspaceRelative(file, context)}`,
+    details: { path: toWorkspaceRelative(file, context), project: context?.project, bytes: Buffer.byteLength(String(params?.content ?? ''), 'utf8') },
+  }
+}
+
+// --- edit_file ---
+function countOccurrences(text, needle) {
+  if (!needle) return 0
+  let count = 0
+  let index = 0
+  while ((index = text.indexOf(needle, index)) !== -1) {
+    count++
+    index += needle.length
+  }
+  return count
+}
+
+export async function toolEditFile(params, context) {
+  const file = resolveWorkspacePath(params?.path, context)
+  assertSafeWorkspacePath(file, context)
+
+  const oldText = String(params?.oldText ?? '')
+  const newText = String(params?.newText ?? '')
+  const text = await fs.readFile(file, 'utf8')
+  const count = countOccurrences(text, oldText)
+
+  if (count !== 1) {
+    const error = new Error(`oldText must match exactly once; found ${count} matches`)
+    error.statusCode = 400
+    throw error
+  }
+
+  await fs.writeFile(file, text.replace(oldText, newText), 'utf8')
+
+  return {
+    content: `Edited ${toWorkspaceRelative(file, context)}`,
+    details: { path: toWorkspaceRelative(file, context), project: context?.project, replaced: count },
+  }
+}
+
+// --- run_command ---
+export async function toolRunCommand(params, context) {
+  const command = String(params?.command || '')
+  if (!command.trim()) {
+    const error = new Error('command is required')
+    error.statusCode = 400
+    throw error
+  }
+
+  const timeoutMs = Math.min(10 * 60, Math.max(1, Number(params?.timeoutSeconds || 60))) * 1000
+
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd: getToolWorkspaceRoot(context),
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    })
+
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    const timer = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGTERM')
+    }, timeoutMs)
+
+    child.stdout.on('data', (chunk) => {
+      stdout = truncateText(stdout + chunk.toString())
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr = truncateText(stderr + chunk.toString())
+    })
+    child.on('close', (code, signal) => {
+      clearTimeout(timer)
+      const content = [
+        `Command: ${command}`,
+        `Exit code: ${code ?? 'unknown'}${signal ? `, signal: ${signal}` : ''}${timedOut ? ' (timed out)' : ''}`,
+        '',
+        'STDOUT:',
+        stdout || '(empty)',
+        '',
+        'STDERR:',
+        stderr || '(empty)',
+      ].join('\n')
+      resolve({ content: truncateText(content), details: { command, project: context?.project, cwd: getToolWorkspaceRoot(context), code, signal, timedOut } })
+    })
+  })
+}
+
+// --- get_project_info ---
+export async function toolGetProjectInfo(_params, context) {
+  if (context?.project) {
+    return {
+      content: `Project: ${context.project.name}\nRoot: ${context.project.path}`,
+      details: { project: context.project, workspaceRoot: context.workspaceRoot },
+    }
+  }
+
+  const config = await readProjectConfig()
+  const project = getActiveProject(config)
+  return {
+    content: `Active project: ${project.name}\nRoot: ${project.path}`,
+    details: { project, workspaceRoot: getWorkspaceRoot() },
+  }
+}
+
+// Helper for grep
+async function walkFiles(root, files = [], context) {
+  const entries = await fs.readdir(root, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name)
+    if (entry.isDirectory()) {
+      if (!shouldSkipSearchDir(entry.name)) await walkFiles(fullPath, files, context)
+    } else if (entry.isFile() && shouldSearchFile(entry.name) && !isSensitiveWorkspacePath(fullPath, context)) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+export const toolHandlers = {
+  get_project_info: toolGetProjectInfo,
+  list_dir: toolListDir,
+  read_file: toolReadFile,
+  grep_files: toolGrepFiles,
+  write_file: toolWriteFile,
+  edit_file: toolEditFile,
+  run_command: toolRunCommand,
+}