ace-pack 0.1.0

package/scripts/ai-memory-config.mjs

@@ -0,0 +1,171 @@
+import path from 'node:path'
+
+import { readTextIfExists } from './ai-memory-utils.mjs'
+
+const DEFAULT_MEMORY_CONFIG = {
+  version: 1,
+  thresholds: {
+    small: {
+      maxFiles: 2,
+      maxDiffLines: 80,
+    },
+    large: {
+      minFiles: 8,
+      minDiffLines: 300,
+    },
+  },
+  highRiskPaths: [],
+  highRiskKeywords: [],
+}
+
+const VALID_TIERS = new Set(['small', 'standard', 'large'])
+
+export async function readMemoryConfig(rootDir) {
+  const configPath = path.join(rootDir, '.ai', 'memory-config.json')
+  const content = await readTextIfExists(configPath)
+
+  if (content === null) {
+    return DEFAULT_MEMORY_CONFIG
+  }
+
+  return normalizeMemoryConfig(JSON.parse(content))
+}
+
+export function normalizeMemoryConfig(config) {
+  const thresholds = {
+    small: {
+      maxFiles: numberOrDefault(config?.thresholds?.small?.maxFiles, 2),
+      maxDiffLines: numberOrDefault(config?.thresholds?.small?.maxDiffLines, 80),
+    },
+    large: {
+      minFiles: numberOrDefault(config?.thresholds?.large?.minFiles, 8),
+      minDiffLines: numberOrDefault(config?.thresholds?.large?.minDiffLines, 300),
+    },
+  }
+
+  return {
+    version: numberOrDefault(config?.version, 1),
+    thresholds,
+    highRiskPaths: normalizeRules(config?.highRiskPaths),
+    highRiskKeywords: normalizeKeywordRules(config?.highRiskKeywords),
+  }
+}
+
+export function getRiskMatches({ changedFiles, config, diffText = '' }) {
+  const matches = []
+  const normalizedFiles = changedFiles.map(normalizeRepoPath)
+  const normalizedDiffText = diffText.toLowerCase()
+
+  for (const rule of config.highRiskPaths) {
+    const matchedFiles = normalizedFiles.filter((filePath) =>
+      matchConfigPattern(filePath, rule.pattern),
+    )
+
+    if (matchedFiles.length > 0) {
+      matches.push({
+        kind: 'path',
+        label: rule.label,
+        matched: matchedFiles,
+        pattern: rule.pattern,
+        requiresDesignReview: rule.requiresDesignReview,
+        tier: rule.tier,
+      })
+    }
+  }
+
+  for (const rule of config.highRiskKeywords) {
+    const keyword = rule.keyword.toLowerCase()
+    const pathMatches = normalizedFiles.filter((filePath) => keywordMatches(filePath, keyword))
+    const diffMatches = keywordMatches(normalizedDiffText, keyword)
+
+    if (pathMatches.length > 0 || diffMatches) {
+      matches.push({
+        kind: 'keyword',
+        label: rule.label,
+        matched: pathMatches,
+        pattern: rule.keyword,
+        requiresDesignReview: rule.requiresDesignReview,
+        tier: rule.tier,
+      })
+    }
+  }
+
+  return matches
+}
+
+export function matchConfigPattern(filePath, pattern) {
+  return globToRegExp(normalizeRepoPath(pattern)).test(normalizeRepoPath(filePath))
+}
+
+export function normalizeRepoPath(filePath) {
+  return filePath.replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
+}
+
+function normalizeRules(value) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value
+    .map((rule) => {
+      if (typeof rule === 'string') {
+        return normalizeRule({ pattern: rule })
+      }
+
+      return normalizeRule(rule)
+    })
+    .filter((rule) => rule.pattern.length > 0)
+}
+
+function normalizeKeywordRules(value) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value
+    .map((rule) => {
+      if (typeof rule === 'string') {
+        return normalizeRule({ keyword: rule, label: rule })
+      }
+
+      return normalizeRule(rule)
+    })
+    .filter((rule) => rule.keyword.length > 0)
+}
+
+function normalizeRule(rule) {
+  const tier = VALID_TIERS.has(rule?.tier) ? rule.tier : 'large'
+  const pattern = typeof rule?.pattern === 'string' ? rule.pattern : ''
+  const keyword = typeof rule?.keyword === 'string' ? rule.keyword : ''
+  const label = typeof rule?.label === 'string' ? rule.label : pattern || keyword
+
+  return {
+    keyword,
+    label,
+    pattern,
+    requiresDesignReview: rule?.requiresDesignReview !== false,
+    tier,
+  }
+}
+
+function numberOrDefault(value, fallback) {
+  return Number.isFinite(value) ? value : fallback
+}
+
+function globToRegExp(pattern) {
+  const escapedPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '__DOUBLE_STAR__')
+    .replace(/\*/g, '[^/]*')
+    .replace(/__DOUBLE_STAR__/g, '.*')
+
+  return new RegExp(`^${escapedPattern}$`, 'u')
+}
+
+function keywordMatches(value, keyword) {
+  return new RegExp(`(^|[^a-z0-9])${escapeRegExp(keyword)}($|[^a-z0-9])`, 'iu').test(value)
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/scripts/ai-memory-utils.mjs

@@ -0,0 +1,372 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+export const ACE_BANNER = '[ACE] Agentic Context Engine initialized...'
+
+const timestampFormatter = new Intl.DateTimeFormat('sv-SE', {
+  day: '2-digit',
+  hour: '2-digit',
+  hour12: false,
+  minute: '2-digit',
+  month: '2-digit',
+  year: 'numeric',
+})
+
+export function normalizeTrailingNewline(content) {
+  return content.endsWith('\n') ? content : `${content}\n`
+}
+
+export async function readTextIfExists(filePath) {
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return null
+    }
+
+    throw error
+  }
+}
+
+export async function writeTextFile(filePath, content) {
+  await mkdir(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, normalizeTrailingNewline(content), 'utf8')
+}
+
+export async function readFileTimestamp(filePath) {
+  try {
+    return (await stat(filePath)).mtime
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return null
+    }
+
+    throw error
+  }
+}
+
+export function formatTimestamp(value) {
+  return timestampFormatter.format(value)
+}
+
+export function nowTimestamp() {
+  return formatTimestamp(new Date())
+}
+
+export function writeAceBanner(output = process.stderr) {
+  output.write(`${ACE_BANNER}\n`)
+}
+
+export function parseCliArgs(args) {
+  const parsed = {}
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]
+
+    if (!token.startsWith('--')) {
+      continue
+    }
+
+    const key = token.slice(2)
+    const nextToken = args[index + 1]
+    const value = nextToken && !nextToken.startsWith('--') ? nextToken : 'true'
+
+    if (value !== 'true') {
+      index += 1
+    }
+
+    const currentValue = parsed[key]
+
+    if (currentValue === undefined) {
+      parsed[key] = value
+      continue
+    }
+
+    if (Array.isArray(currentValue)) {
+      currentValue.push(value)
+      continue
+    }
+
+    parsed[key] = [currentValue, value]
+  }
+
+  return parsed
+}
+
+export function getArgList(args, key) {
+  const value = args[key]
+
+  if (value === undefined) {
+    return []
+  }
+
+  return Array.isArray(value) ? value : [value]
+}
+
+export function getArgValue(args, key) {
+  const value = args[key]
+
+  if (Array.isArray(value)) {
+    return value.at(-1)
+  }
+
+  return value
+}
+
+export function formatBullets(items, fallback = '- [Add content here]') {
+  if (items.length === 0) {
+    return fallback
+  }
+
+  return items.map((item) => `- ${item}`).join('\n')
+}
+
+export function formatChecklist(items, fallback = '- [ ] Add checklist item') {
+  if (items.length === 0) {
+    return fallback
+  }
+
+  return items.map((item) => (item.startsWith('- [') ? item : `- [ ] ${item}`)).join('\n')
+}
+
+export function replaceMarkdownSection(content, heading, body) {
+  const lines = content.split(/\r?\n/)
+  const startIndex = lines.findIndex((line) => line === `## ${heading}`)
+
+  if (startIndex === -1) {
+    return content
+  }
+
+  let endIndex = lines.length
+
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (lines[index].startsWith('## ')) {
+      endIndex = index
+      break
+    }
+  }
+
+  const replacementLines = [`## ${heading}`, ...body.trimEnd().split('\n')]
+  const nextLines = [
+    ...lines.slice(0, startIndex),
+    ...replacementLines,
+    '',
+    ...lines.slice(endIndex),
+  ]
+
+  return normalizeTrailingNewline(nextLines.join('\n')).replace(/\n{3,}/g, '\n\n')
+}
+
+export function extractMarkdownSection(content, heading) {
+  const lines = content.split(/\r?\n/)
+  const startIndex = lines.findIndex((line) => line === `## ${heading}`)
+
+  if (startIndex === -1) {
+    return ''
+  }
+
+  let endIndex = lines.length
+
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (lines[index].startsWith('## ')) {
+      endIndex = index
+      break
+    }
+  }
+
+  return lines
+    .slice(startIndex + 1, endIndex)
+    .join('\n')
+    .trim()
+}
+
+export function replaceLabeledValue(content, label, value) {
+  const pattern = new RegExp(`^${escapeRegExp(label)}:.*$`, 'm')
+  return content.replace(pattern, `${label}: ${value}`)
+}
+
+export function countCheckboxes(content) {
+  const total = (content.match(/^- \[(?: |x)\]/gm) ?? []).length
+  const complete = (content.match(/^- \[x\]/gm) ?? []).length
+
+  return { complete, total }
+}
+
+export function extractTopDecision(content) {
+  const match = content.match(/^## .+?(?:\r?\n[\s\S]*?)(?=^## |\Z)/m)
+  return match ? match[0].trim() : ''
+}
+
+export function extractChangedFileTitles(content, limit = 8) {
+  const headings = [...content.matchAll(/^\[(.+?)\]$/gm)].map((match) => match[1])
+  const recentPaths = []
+
+  for (const heading of headings) {
+    if (!isChangedPathHeading(heading) || recentPaths.includes(heading)) {
+      continue
+    }
+
+    recentPaths.push(heading)
+
+    if (recentPaths.length >= limit) {
+      break
+    }
+  }
+
+  return recentPaths
+}
+
+export function extractUnresolvedReflections(content, limit = 5) {
+  const unresolvedSection = extractMarkdownSection(content, 'Unresolved')
+
+  if (!unresolvedSection) {
+    return []
+  }
+
+  const entries = extractHeadingBlocks(unresolvedSection, '###')
+    .filter((entry) => !/Status:\s*resolved/i.test(entry.body))
+    .filter((entry) => !/\[[^\]]+\]/.test(`${entry.title}\n${entry.body}`))
+
+  return entries.slice(0, limit).map((entry) => {
+    const summary =
+      entry.body
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^- /, '').trim())
+        .find((line) => line.length > 0 && !line.startsWith('Status:')) ?? 'No summary recorded.'
+
+    return `${entry.title} - ${summary}`
+  })
+}
+
+function extractHeadingBlocks(content, headingMarker) {
+  const lines = content.split(/\r?\n/)
+  const entries = []
+  let currentEntry = null
+
+  for (const line of lines) {
+    if (line.startsWith(`${headingMarker} `)) {
+      if (currentEntry) {
+        entries.push(currentEntry)
+      }
+
+      currentEntry = {
+        bodyLines: [],
+        title: line.slice(headingMarker.length + 1).trim(),
+      }
+      continue
+    }
+
+    if (currentEntry) {
+      currentEntry.bodyLines.push(line)
+    }
+  }
+
+  if (currentEntry) {
+    entries.push(currentEntry)
+  }
+
+  return entries.map((entry) => ({
+    body: entry.bodyLines.join('\n').trim(),
+    title: entry.title,
+  }))
+}
+
+export function normalizeStackText(content) {
+  return content
+    .replace(/•/g, ' | ')
+    .replace(/[•·]/g, ' | ')
+    .replace(/\s*\|\s*/g, ' | ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export function summarizeVerification(content, limit = 4) {
+  const checks = extractBulletBlocks(content)
+  const signals = checks.join('\n').toLowerCase()
+
+  let level = 'not recorded'
+
+  if (/smoke|browser|playwright|manual|loaded /.test(signals)) {
+    level = 'smoke-tested'
+  } else if (/\btest\b|vitest|passed/.test(signals)) {
+    level = 'test-backed'
+  } else if (/typecheck|tsc/.test(signals)) {
+    level = 'typecheck-only'
+  } else if (/\blint\b/.test(signals)) {
+    level = 'static checks only'
+  }
+
+  return {
+    checks: checks.slice(0, limit),
+    level,
+  }
+}
+
+export function getFreshnessStatus(generatedAt, ...sourceDates) {
+  const latestSource = sourceDates
+    .filter((value) => value instanceof Date)
+    .sort((left, right) => right.getTime() - left.getTime())
+    .at(0)
+
+  if (!latestSource) {
+    return 'Possibly stale'
+  }
+
+  return generatedAt.getTime() >= latestSource.getTime() ? 'Fresh' : 'Possibly stale'
+}
+
+export function extractLabeledValue(content, label) {
+  const pattern = new RegExp(`^${escapeRegExp(label)}:\\s*(.+)$`, 'm')
+  return content.match(pattern)?.[1]?.trim() ?? ''
+}
+
+function isChangedPathHeading(heading) {
+  if (/\s-\s\d{4}-\d{2}-\d{2}(?:[ -]\d{2}:\d{2})?$/.test(heading)) {
+    return false
+  }
+
+  return (
+    heading.startsWith('.') ||
+    heading.includes('*') ||
+    heading.includes('/') ||
+    heading.includes('\\') ||
+    /\.[a-z0-9]+(?:$|\s)/i.test(heading)
+  )
+}
+
+function extractBulletBlocks(content) {
+  const lines = content.split(/\r?\n/)
+  const blocks = []
+  let currentBlock = []
+
+  for (const line of lines) {
+    if (line.startsWith('- ')) {
+      if (currentBlock.length > 0) {
+        blocks.push(currentBlock.join('\n').trim())
+      }
+
+      currentBlock = [line.slice(2)]
+      continue
+    }
+
+    if (currentBlock.length > 0 && (/^\s{2,}\S/.test(line) || line.trim() === '')) {
+      currentBlock.push(line.trim())
+      continue
+    }
+
+    if (currentBlock.length > 0) {
+      blocks.push(currentBlock.join('\n').trim())
+      currentBlock = []
+    }
+  }
+
+  if (currentBlock.length > 0) {
+    blocks.push(currentBlock.join('\n').trim())
+  }
+
+  return blocks.filter(Boolean)
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/scripts/ai-report-brief.mjs

@@ -0,0 +1,131 @@
+import path from 'node:path'
+
+import {
+  countCheckboxes,
+  extractChangedFileTitles,
+  extractLabeledValue,
+  extractMarkdownSection,
+  extractTopDecision,
+  extractUnresolvedReflections,
+  formatTimestamp,
+  getFreshnessStatus,
+  normalizeStackText,
+  readFileTimestamp,
+  readTextIfExists,
+  summarizeVerification,
+  writeTextFile,
+} from './ai-memory-utils.mjs'
+
+const rootDir = process.argv[2] ? path.resolve(process.cwd(), process.argv[2]) : process.cwd()
+const aiDir = path.join(rootDir, '.ai')
+const currentTaskPath = path.join(aiDir, 'current-task.md')
+const handoffPath = path.join(aiDir, 'session-handoff.md')
+
+const [
+  packageJsonContent,
+  agentsContent,
+  currentTaskContent,
+  handoffContent,
+  decisionsContent,
+  changedFilesContent,
+  reflectionLogContent,
+  currentTaskTimestamp,
+  handoffTimestamp,
+] = await Promise.all([
+  readTextIfExists(path.join(rootDir, 'package.json')),
+  readTextIfExists(path.join(rootDir, 'AGENTS.md')),
+  readTextIfExists(currentTaskPath),
+  readTextIfExists(handoffPath),
+  readTextIfExists(path.join(aiDir, 'decisions.md')),
+  readTextIfExists(path.join(aiDir, 'changed-files.md')),
+  readTextIfExists(path.join(aiDir, 'reflection-log.md')),
+  readFileTimestamp(currentTaskPath),
+  readFileTimestamp(handoffPath),
+])
+
+if (
+  packageJsonContent === null ||
+  agentsContent === null ||
+  currentTaskContent === null ||
+  handoffContent === null ||
+  decisionsContent === null ||
+  changedFilesContent === null
+) {
+  throw new Error('Missing package, AGENTS.md, or required .ai/* files for ai:report:brief.')
+}
+
+const packageJson = JSON.parse(packageJsonContent)
+const lifecycle = extractMarkdownSection(currentTaskContent, 'Lifecycle')
+const currentStatus = extractMarkdownSection(currentTaskContent, 'Current Status')
+const nextSteps = extractMarkdownSection(handoffContent, 'Next Steps')
+const knownIssues = extractMarkdownSection(handoffContent, 'Known Issues')
+const verification = summarizeVerification(extractMarkdownSection(handoffContent, 'Verification'))
+const generatedAt = new Date()
+const stack = normalizeStackText(extractMarkdownSection(agentsContent, 'Stack (non-negotiable)'))
+const checklist = countCheckboxes(
+  extractMarkdownSection(currentTaskContent, 'Completion Checklist'),
+)
+const changedAreas = extractChangedFileTitles(changedFilesContent, 6)
+const topDecision = extractTopDecision(decisionsContent)
+const unresolvedReflections = extractUnresolvedReflections(reflectionLogContent ?? '', 5)
+const freshness = getFreshnessStatus(generatedAt, currentTaskTimestamp, handoffTimestamp)
+const currentTaskVersion = extractLabeledValue(lifecycle, 'Version') || 'unknown'
+const currentTaskTier = extractLabeledValue(lifecycle, 'Task Tier') || 'unknown'
+
+const briefReport = `# AI Brief Report
+
+Project: \`${packageJson.name}\`
+
+## Report Metadata
+- Generated: ${formatTimestamp(generatedAt)}
+- Freshness: ${freshness}
+- Current task version: ${currentTaskVersion}
+- Current task tier: ${currentTaskTier}
+- Source current-task: ${currentTaskTimestamp ? formatTimestamp(currentTaskTimestamp) : 'Unknown'}
+- Source session-handoff: ${handoffTimestamp ? formatTimestamp(handoffTimestamp) : 'Unknown'}
+- Verification level: ${verification.level}
+
+## Stack
+${stack}
+
+## Current Task
+${extractMarkdownSection(currentTaskContent, 'Feature Name')}
+
+## Lifecycle
+${lifecycle}
+
+## Goal
+${extractMarkdownSection(currentTaskContent, 'Goal')}
+
+## Business Value
+${extractMarkdownSection(currentTaskContent, 'Business Value / Product Alignment') || '- Not recorded.'}
+
+## Current Status
+${currentStatus}
+
+## Next Steps
+${nextSteps || '- No next steps recorded.'}
+
+## Risks / Blockers
+${knownIssues || '- No known issues recorded.'}
+
+## Verification
+${verification.checks.length > 0 ? verification.checks.map((item) => `- ${item}`).join('\n') : '- No verification recorded.'}
+
+## Recent Decision
+${topDecision || 'No durable decisions recorded yet.'}
+
+## Unresolved Reflections
+${unresolvedReflections.length > 0 ? unresolvedReflections.map((item) => `- ${item}`).join('\n') : '- No unresolved reflections recorded.'}
+
+## Changed Areas
+${changedAreas.length > 0 ? changedAreas.map((item) => `- \`${item}\``).join('\n') : '- No changed files recorded.'}
+
+## Overall Progress
+- Completion checklist: ${checklist.complete}/${checklist.total}
+- Source of truth: \`.ai/*\` files remain authoritative.
+`
+
+const outputPath = path.join(aiDir, 'report-brief.md')
+await writeTextFile(outputPath, briefReport)
+process.stderr.write(`Generated ${outputPath}\n`)