@thxgg/steward 0.1.0

package/server/api/repos/[repoId]/prd/[prdSlug]/tasks.get.ts

@@ -0,0 +1,36 @@
+import { getRepos } from '~~/server/utils/repos'
+import { getPrdState, migrateLegacyStateForRepo } from '~~/server/utils/prd-state'
+
+export default defineEventHandler(async (event) => {
+  const repoId = getRouterParam(event, 'repoId')
+  const prdSlug = getRouterParam(event, 'prdSlug')
+
+  if (!repoId || !prdSlug) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Repository ID and PRD slug are required'
+    })
+  }
+
+  const repos = await getRepos()
+  const repo = repos.find(r => r.id === repoId)
+
+  if (!repo) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Repository not found'
+    })
+  }
+
+  await migrateLegacyStateForRepo(repo)
+
+  try {
+    const state = await getPrdState(repo.id, prdSlug)
+    return state?.tasks ?? null
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to read task state: ${(error as Error).message}`
+    })
+  }
+})

package/server/api/repos/[repoId]/prd/[prdSlug].get.ts

@@ -0,0 +1,97 @@
+import { promises as fs } from 'node:fs'
+import { join } from 'node:path'
+import { getRepos } from '~~/server/utils/repos'
+import type { PrdDocument, PrdMetadata } from '~~/app/types/prd'
+
+function parseMetadata(content: string): PrdMetadata {
+  const metadata: PrdMetadata = {}
+
+  // Look for metadata patterns in the document header
+  // Formats: "**Author:** Value" or "Author: Value"
+
+  // Author - match **Author:** or Author: and capture the value
+  const authorMatch = content.match(/\*{0,2}Author\*{0,2}:\*{0,2}\s*(.+?)(?:\n|$)/i)
+  if (authorMatch && authorMatch[1]) {
+    metadata.author = authorMatch[1].trim()
+  }
+
+  // Date
+  const dateMatch = content.match(/\*{0,2}Date\*{0,2}:\*{0,2}\s*(.+?)(?:\n|$)/i)
+  if (dateMatch && dateMatch[1]) {
+    metadata.date = dateMatch[1].trim()
+  }
+
+  // Status
+  const statusMatch = content.match(/\*{0,2}Status\*{0,2}:\*{0,2}\s*(.+?)(?:\n|$)/i)
+  if (statusMatch && statusMatch[1]) {
+    metadata.status = statusMatch[1].trim()
+  }
+
+  // Shortcut Story - look for link format [SC-XXX](url) or just SC-XXX
+  const shortcutLinkMatch = content.match(/\[([Ss][Cc]-\d+)\]\(([^)]+)\)/)
+  if (shortcutLinkMatch && shortcutLinkMatch[1] && shortcutLinkMatch[2]) {
+    metadata.shortcutStory = shortcutLinkMatch[1]
+    metadata.shortcutUrl = shortcutLinkMatch[2]
+  } else {
+    // Try just the ID pattern
+    const shortcutIdMatch = content.match(/\*{0,2}Shortcut(?:\s+Story)?\*{0,2}:\*{0,2}\s*([Ss][Cc]-\d+)/i)
+    if (shortcutIdMatch && shortcutIdMatch[1]) {
+      metadata.shortcutStory = shortcutIdMatch[1]
+    }
+  }
+
+  return metadata
+}
+
+export default defineEventHandler(async (event) => {
+  const repoId = getRouterParam(event, 'repoId')
+  const prdSlug = getRouterParam(event, 'prdSlug')
+
+  if (!repoId || !prdSlug) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Repository ID and PRD slug are required'
+    })
+  }
+
+  const repos = await getRepos()
+  const repo = repos.find(r => r.id === repoId)
+
+  if (!repo) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Repository not found'
+    })
+  }
+
+  const prdPath = join(repo.path, 'docs', 'prd', `${prdSlug}.md`)
+
+  let content: string
+  try {
+    content = await fs.readFile(prdPath, 'utf-8')
+  } catch {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'PRD not found'
+    })
+  }
+
+  // Extract title from first H1
+  let name = prdSlug
+  const h1Match = content.match(/^#\s+(.+)$/m)
+  if (h1Match && h1Match[1]) {
+    name = h1Match[1].trim()
+  }
+
+  // Parse metadata from document
+  const metadata = parseMetadata(content)
+
+  const document: PrdDocument = {
+    slug: prdSlug,
+    name,
+    content,
+    metadata
+  }
+
+  return document
+})

package/server/api/repos/[repoId]/prds.get.ts

@@ -0,0 +1,85 @@
+import { promises as fs } from 'node:fs'
+import { join, basename } from 'node:path'
+import { getRepos } from '~~/server/utils/repos'
+import { getPrdStateSummaries, migrateLegacyStateForRepo } from '~~/server/utils/prd-state'
+import type { PrdListItem } from '~~/app/types/prd'
+
+export default defineEventHandler(async (event) => {
+  const repoId = getRouterParam(event, 'repoId')
+
+  if (!repoId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Repository ID is required'
+    })
+  }
+
+  const repos = await getRepos()
+  const repo = repos.find(r => r.id === repoId)
+
+  if (!repo) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Repository not found'
+    })
+  }
+
+  await migrateLegacyStateForRepo(repo)
+
+  const prdDir = join(repo.path, 'docs', 'prd')
+
+  let prdFiles: string[] = []
+  try {
+    const files = await fs.readdir(prdDir)
+    prdFiles = files.filter(f => f.endsWith('.md'))
+  } catch {
+    // docs/prd doesn't exist, return empty array
+    return []
+  }
+
+  const stateSummaries = await getPrdStateSummaries(repo.id)
+
+  const prds: PrdListItem[] = await Promise.all(
+    prdFiles.map(async (filename) => {
+      const slug = basename(filename, '.md')
+      const filePath = join(prdDir, filename)
+
+      // Get file modification time and extract title from first H1
+      let name = slug
+      let modifiedAt = 0
+      try {
+        const [content, stat] = await Promise.all([
+          fs.readFile(filePath, 'utf-8'),
+          fs.stat(filePath)
+        ])
+        modifiedAt = stat.mtime.getTime()
+        const h1Match = content.match(/^#\s+(.+)$/m)
+        if (h1Match && h1Match[1]) {
+          name = h1Match[1].trim()
+        }
+      } catch {
+        // Couldn't read file, use slug as name
+      }
+
+      const stateSummary = stateSummaries.get(slug)
+      const hasState = !!stateSummary?.hasState
+      const taskCount = stateSummary?.taskCount
+      const completedCount = stateSummary?.completedCount
+
+      return {
+        slug,
+        name,
+        source: `docs/prd/${filename}`,
+        hasState,
+        modifiedAt,
+        ...(taskCount !== undefined && { taskCount }),
+        ...(completedCount !== undefined && { completedCount })
+      }
+    })
+  )
+
+  // Sort by modification time descending (most recent first)
+  prds.sort((a, b) => b.modifiedAt - a.modifiedAt)
+
+  return prds
+})

package/server/api/repos/[repoId]/refresh-git-repos.post.ts

@@ -0,0 +1,42 @@
+import { getRepos, saveRepos, discoverGitRepos } from '~~/server/utils/repos'
+
+export default defineEventHandler(async (event) => {
+  const repoId = getRouterParam(event, 'repoId')
+
+  if (!repoId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Repository ID is required',
+    })
+  }
+
+  const repos = await getRepos()
+  const repoIndex = repos.findIndex(r => r.id === repoId)
+
+  if (repoIndex === -1) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Repository not found',
+    })
+  }
+
+  const repo = repos[repoIndex]!
+
+  // Re-discover git repos
+  const gitRepos = await discoverGitRepos(repo.path)
+
+  // Update the repo config
+  if (gitRepos.length > 0) {
+    repo.gitRepos = gitRepos
+  } else {
+    delete repo.gitRepos
+  }
+
+  repos[repoIndex] = repo
+  await saveRepos(repos)
+
+  return {
+    discovered: gitRepos.length,
+    gitRepos,
+  }
+})

package/server/api/repos/[repoId].delete.ts

@@ -0,0 +1,27 @@
+import { removeRepo } from '~~/server/utils/repos'
+import { refreshWatcher } from '~~/server/utils/watcher'
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, 'repoId')
+
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Repository ID is required'
+    })
+  }
+
+  const removed = await removeRepo(id)
+
+  if (!removed) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Repository not found'
+    })
+  }
+
+  // Refresh file watcher to remove repo from watch list
+  await refreshWatcher()
+
+  return { success: true }
+})

package/server/api/repos/index.get.ts

@@ -0,0 +1,5 @@
+import { getRepos } from '~~/server/utils/repos'
+
+export default defineEventHandler(async () => {
+  return await getRepos()
+})

package/server/api/repos/index.post.ts

@@ -0,0 +1,39 @@
+import { addRepo, validateRepoPath } from '~~/server/utils/repos'
+import { migrateLegacyStateForRepo } from '~~/server/utils/prd-state'
+import { refreshWatcher } from '~~/server/utils/watcher'
+import type { AddRepoRequest } from '~~/app/types/repo'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody<AddRepoRequest>(event)
+
+  if (!body?.path) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Path is required'
+    })
+  }
+
+  const validation = await validateRepoPath(body.path)
+  if (!validation.valid) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: validation.error || 'Invalid path'
+    })
+  }
+
+  try {
+    const repo = await addRepo(body.path, body.name)
+    await migrateLegacyStateForRepo(repo)
+    // Refresh file watcher to include new repo
+    await refreshWatcher()
+    return repo
+  } catch (error) {
+    if (error instanceof Error && error.message === 'Repository already added') {
+      throw createError({
+        statusCode: 409,
+        statusMessage: 'Repository already added'
+      })
+    }
+    throw error
+  }
+})

package/server/api/watch.get.ts

@@ -0,0 +1,63 @@
+import { initWatcher, addListener, type FileChangeEvent } from '~~/server/utils/watcher'
+
+export default defineEventHandler(async (event) => {
+  // Initialize watcher if not already done
+  await initWatcher()
+
+  // Set headers for SSE
+  setHeader(event, 'Content-Type', 'text/event-stream')
+  setHeader(event, 'Cache-Control', 'no-cache')
+  setHeader(event, 'Connection', 'keep-alive')
+
+  // Create a response stream
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send initial connection event
+      const connectMsg = `data: ${JSON.stringify({ type: 'connected' })}\n\n`
+      controller.enqueue(new TextEncoder().encode(connectMsg))
+
+      // Add listener for file changes
+      const removeListener = addListener((fileEvent: FileChangeEvent) => {
+        const msg = `data: ${JSON.stringify(fileEvent)}\n\n`
+        try {
+          controller.enqueue(new TextEncoder().encode(msg))
+        } catch {
+          // Stream closed, clean up
+          removeListener()
+        }
+      })
+
+      // Handle client disconnect
+      event.node.req.on('close', () => {
+        removeListener()
+        try {
+          controller.close()
+        } catch {
+          // Already closed
+        }
+      })
+
+      // Send keepalive every 30 seconds
+      const keepaliveInterval = setInterval(() => {
+        try {
+          const ping = `: keepalive\n\n`
+          controller.enqueue(new TextEncoder().encode(ping))
+        } catch {
+          clearInterval(keepaliveInterval)
+        }
+      }, 30000)
+
+      event.node.req.on('close', () => {
+        clearInterval(keepaliveInterval)
+      })
+    }
+  })
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive'
+    }
+  })
+})

package/server/plugins/migrate-legacy-state.ts

@@ -0,0 +1,19 @@
+import { getRepos } from '~~/server/utils/repos'
+import { migrateLegacyStateForRepo } from '~~/server/utils/prd-state'
+
+export default defineNitroPlugin((nitroApp) => {
+  // Run on startup
+  nitroApp.hooks.hook('ready' as any, async () => {
+    try {
+      const repos = await getRepos()
+      for (const repo of repos) {
+        // Run migration in the background
+        migrateLegacyStateForRepo(repo).catch(err => {
+          console.error(`Failed to migrate legacy state for repo ${repo.name}:`, err)
+        })
+      }
+    } catch (err) {
+      console.error('Failed to run startup migration:', err)
+    }
+  })
+})

package/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../.nuxt/tsconfig.server.json"
+}

package/server/utils/db.ts

@@ -0,0 +1,169 @@
+import { promises as fs } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { homedir } from 'node:os'
+
+type SqlParam = string | number | bigint | Uint8Array | null
+type SqlRow = Record<string, unknown>
+
+type SqlRunResult = {
+  changes: number
+}
+
+type SqliteAdapter = {
+  exec: (sql: string) => void
+  run: (sql: string, params?: SqlParam[]) => SqlRunResult
+  get: <T extends SqlRow>(sql: string, params?: SqlParam[]) => T | null
+  all: <T extends SqlRow>(sql: string, params?: SqlParam[]) => T[]
+}
+
+const DEFAULT_DATA_HOME = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share')
+const DEFAULT_DB_PATH = join(DEFAULT_DATA_HOME, 'prd', 'state.db')
+
+let adapterPromise: Promise<SqliteAdapter> | null = null
+
+function coerceChanges(result: unknown): number {
+  if (!result || typeof result !== 'object') {
+    return 0
+  }
+
+  const maybeChanges = (result as { changes?: unknown }).changes
+  return typeof maybeChanges === 'number' ? maybeChanges : 0
+}
+
+function resolveDbPath(): string {
+  const customPath = process.env.PRD_STATE_DB_PATH
+  if (customPath && customPath.trim().length > 0) {
+    return customPath
+  }
+
+  const customHome = process.env.PRD_STATE_HOME
+  if (customHome && customHome.trim().length > 0) {
+    return join(customHome, 'state.db')
+  }
+
+  return DEFAULT_DB_PATH
+}
+
+export function getDbPath(): string {
+  return resolveDbPath()
+}
+
+async function createNodeAdapter(dbPath: string): Promise<SqliteAdapter> {
+  const sqliteModule = await import('node:sqlite')
+  const db = new sqliteModule.DatabaseSync(dbPath)
+
+  return {
+    exec(sql: string) {
+      db.exec(sql)
+    },
+    run(sql: string, params: SqlParam[] = []) {
+      const result = db.prepare(sql).run(...params)
+      return { changes: coerceChanges(result) }
+    },
+    get<T extends SqlRow>(sql: string, params: SqlParam[] = []) {
+      const row = db.prepare(sql).get(...params)
+      return row ? (row as T) : null
+    },
+    all<T extends SqlRow>(sql: string, params: SqlParam[] = []) {
+      return db.prepare(sql).all(...params) as T[]
+    }
+  }
+}
+
+async function createBunAdapter(dbPath: string): Promise<SqliteAdapter> {
+  const bunModuleName = 'bun:sqlite'
+  const sqliteModule = await import(bunModuleName)
+  const Database = (sqliteModule as { Database: new (path: string, options?: { create?: boolean }) => {
+    exec: (sql: string) => void
+    query: (sql: string) => {
+      run: (...params: SqlParam[]) => unknown
+      get: (...params: SqlParam[]) => SqlRow | null
+      all: (...params: SqlParam[]) => SqlRow[]
+    }
+  } }).Database
+
+  const db = new Database(dbPath, { create: true })
+
+  return {
+    exec(sql: string) {
+      db.exec(sql)
+    },
+    run(sql: string, params: SqlParam[] = []) {
+      const result = db.query(sql).run(...params)
+      return { changes: coerceChanges(result) }
+    },
+    get<T extends SqlRow>(sql: string, params: SqlParam[] = []) {
+      const row = db.query(sql).get(...params) as T | null | undefined
+      return row ?? null
+    },
+    all<T extends SqlRow>(sql: string, params: SqlParam[] = []) {
+      return db.query(sql).all(...params) as T[]
+    }
+  }
+}
+
+async function initializeDatabase(): Promise<SqliteAdapter> {
+  const dbPath = resolveDbPath()
+  await fs.mkdir(dirname(dbPath), { recursive: true })
+
+  const isBunRuntime = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'
+  const adapter = isBunRuntime
+    ? await createBunAdapter(dbPath)
+    : await createNodeAdapter(dbPath)
+
+  adapter.exec('PRAGMA journal_mode = WAL;')
+  adapter.exec('PRAGMA foreign_keys = ON;')
+  adapter.exec('PRAGMA busy_timeout = 5000;')
+
+  adapter.exec(`
+    CREATE TABLE IF NOT EXISTS repos (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL UNIQUE,
+      added_at TEXT NOT NULL,
+      git_repos_json TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS prd_states (
+      repo_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      tasks_json TEXT,
+      progress_json TEXT,
+      notes_md TEXT,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (repo_id, slug),
+      FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_prd_states_repo_id ON prd_states(repo_id);
+  `)
+
+  return adapter
+}
+
+async function getAdapter(): Promise<SqliteAdapter> {
+  if (!adapterPromise) {
+    adapterPromise = initializeDatabase()
+  }
+  return adapterPromise
+}
+
+export async function dbRun(sql: string, params: SqlParam[] = []): Promise<SqlRunResult> {
+  const adapter = await getAdapter()
+  return adapter.run(sql, params)
+}
+
+export async function dbGet<T extends SqlRow>(sql: string, params: SqlParam[] = []): Promise<T | null> {
+  const adapter = await getAdapter()
+  return adapter.get<T>(sql, params)
+}
+
+export async function dbAll<T extends SqlRow>(sql: string, params: SqlParam[] = []): Promise<T[]> {
+  const adapter = await getAdapter()
+  return adapter.all<T>(sql, params)
+}
+
+export async function dbExec(sql: string): Promise<void> {
+  const adapter = await getAdapter()
+  adapter.exec(sql)
+}