ace-pack 0.1.0

package/scripts/ai-report-current-task-code.mjs

@@ -0,0 +1,128 @@
+import { execFile } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import { promisify } from 'node:util'
+
+import { formatTimestamp, readTextIfExists, writeTextFile } from './ai-memory-utils.mjs'
+
+const execFileAsync = promisify(execFile)
+
+const rootDir = process.argv[2] ? path.resolve(process.cwd(), process.argv[2]) : process.cwd()
+const aiDir = path.join(rootDir, '.ai')
+const outputMdPath = path.join(aiDir, 'report-current-task-code.md')
+const outputXmlPath = path.join(aiDir, 'report-current-task-code.xml')
+
+const packageJsonContent = await readTextIfExists(path.join(rootDir, 'package.json'))
+if (packageJsonContent === null) {
+  throw new Error('Missing package.json for ai:report:current-task-code.')
+}
+
+const packageJson = JSON.parse(packageJsonContent)
+const generatedAt = new Date()
+
+const isCodeFile = (filePath) =>
+  !filePath.startsWith('.ai/') &&
+  !filePath.startsWith('node_modules/') &&
+  (/\.(ts|tsx|js|mjs|cjs|json)$/u.test(filePath) || filePath === 'package.json')
+
+const getTrackedAndUntrackedFiles = async () => {
+  const [statusResult, untrackedResult] = await Promise.all([
+    execFileAsync('git', ['status', '--porcelain'], { cwd: rootDir, encoding: 'utf8' }),
+    execFileAsync('git', ['ls-files', '--others', '--exclude-standard'], {
+      cwd: rootDir,
+      encoding: 'utf8',
+    }),
+  ])
+
+  const trackedModifiedFiles = statusResult.stdout
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .map((line) => line.slice(3))
+    .filter((filePath) => filePath.length > 0)
+
+  const untrackedFiles = untrackedResult.stdout
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+
+  return [...new Set([...trackedModifiedFiles, ...untrackedFiles])].filter(isCodeFile)
+}
+
+const safeReadFile = async (filePath) => {
+  try {
+    return await readFile(path.join(rootDir, filePath), 'utf8')
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return null
+    }
+
+    throw error
+  }
+}
+
+const escapeXml = (value) =>
+  value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+
+const codeFiles = await getTrackedAndUntrackedFiles()
+const fileEntries = await Promise.all(
+  codeFiles.map(async (filePath) => ({
+    path: filePath,
+    content: await safeReadFile(filePath),
+  })),
+)
+
+const entries = fileEntries.filter((entry) => entry.content !== null)
+const missingFiles = fileEntries.filter((entry) => entry.content === null)
+
+const md = [
+  '# AI Current Task Code Report',
+  '',
+  `Project: \`${packageJson.name}\``,
+  `Generated: ${formatTimestamp(generatedAt)}`,
+  '',
+  ...(missingFiles.length > 0
+    ? [
+        '## Missing Files',
+        ...missingFiles.map((entry) => `- \`${entry.path}\` (file missing at report time)`),
+        '',
+      ]
+    : []),
+  '## Files',
+  ...entries.flatMap((entry) => [
+    `### \`${entry.path}\``,
+    '```ts',
+    entry.content.trimEnd(),
+    '```',
+    '',
+  ]),
+].join('\n')
+
+const xml = [
+  '<?xml version="1.0" encoding="UTF-8"?>',
+  `<current-task-code-report project="${escapeXml(packageJson.name)}" generated="${escapeXml(formatTimestamp(generatedAt))}">`,
+  ...(missingFiles.length > 0
+    ? [
+        '  <missing-files>',
+        ...missingFiles.map(
+          (entry) => `    <file path="${escapeXml(entry.path)}" reason="missing-at-report-time" />`,
+        ),
+        '  </missing-files>',
+      ]
+    : []),
+  ...entries.map(
+    (entry) =>
+      `  <file path="${escapeXml(entry.path)}"><![CDATA[${entry.content.trimEnd()}]]></file>`,
+  ),
+  '</current-task-code-report>',
+].join('\n')
+
+await writeTextFile(outputMdPath, md)
+await writeTextFile(outputXmlPath, xml)
+
+process.stderr.write(`Generated ${outputMdPath}\nGenerated ${outputXmlPath}\n`)

package/scripts/ai-report.mjs

@@ -0,0 +1,185 @@
+import { spawn } from 'node:child_process'
+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 fullReportPath = path.join(aiDir, 'report-full.md')
+const xmlReportPath = path.join(aiDir, 'report-full.xml')
+const currentTaskPath = path.join(aiDir, 'current-task.md')
+const handoffPath = path.join(aiDir, 'session-handoff.md')
+const shouldSkipXml = process.env.AI_REPORT_SKIP_XML === '1'
+
+const [
+  packageJsonContent,
+  agentsContent,
+  currentTaskContent,
+  handoffContent,
+  decisionsContent,
+  changedFilesContent,
+  workLogContent,
+  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, 'work-log.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 ||
+  workLogContent === null
+) {
+  throw new Error('Missing package, AGENTS.md, or required .ai/* files for ai:report.')
+}
+
+const packageJson = JSON.parse(packageJsonContent)
+const lifecycle = extractMarkdownSection(currentTaskContent, 'Lifecycle')
+const generatedAt = new Date()
+const checklist = countCheckboxes(
+  extractMarkdownSection(currentTaskContent, 'Completion Checklist'),
+)
+const changedAreas = extractChangedFileTitles(changedFilesContent, 8)
+const verification = summarizeVerification(
+  extractMarkdownSection(handoffContent, 'Verification'),
+  6,
+)
+const freshness = getFreshnessStatus(generatedAt, currentTaskTimestamp, handoffTimestamp)
+const currentTaskVersion = extractLabeledValue(lifecycle, 'Version') || 'unknown'
+const currentTaskTier = extractLabeledValue(lifecycle, 'Task Tier') || 'unknown'
+const unresolvedReflections = extractUnresolvedReflections(reflectionLogContent ?? '', 5)
+const fullReport = `# AI Full 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
+${normalizeStackText(extractMarkdownSection(agentsContent, 'Stack (non-negotiable)'))}
+
+## Architecture Rules
+${extractMarkdownSection(agentsContent, 'Architecture rules').trim()}
+
+## Current Task
+${extractMarkdownSection(currentTaskContent, 'Feature Name')}
+
+## Lifecycle
+${lifecycle}
+
+## Goal
+${extractMarkdownSection(currentTaskContent, 'Goal')}
+
+## Business Value
+${extractMarkdownSection(currentTaskContent, 'Business Value / Product Alignment') || '- Not recorded.'}
+
+## Technical Approach
+${extractMarkdownSection(currentTaskContent, 'Technical Approach') || '- Not recorded.'}
+
+## Current Status
+${extractMarkdownSection(currentTaskContent, 'Current Status')}
+
+## What Was Done
+${extractMarkdownSection(handoffContent, 'What Was Done')}
+
+## Current State
+${extractMarkdownSection(handoffContent, 'Current State')}
+
+## Next Steps
+${extractMarkdownSection(handoffContent, 'Next Steps')}
+
+## Known Issues
+${extractMarkdownSection(handoffContent, 'Known Issues')}
+
+## Quality Review
+${extractMarkdownSection(handoffContent, 'Quality Review') || '- Not recorded.'}
+
+## Verification
+${verification.checks.length > 0 ? verification.checks.map((item) => `- ${item}`).join('\n') : '- No verification recorded.'}
+
+## Recent Decisions
+${extractTopDecision(decisionsContent) || 'No durable decisions recorded yet.'}
+
+## Changed Areas
+${changedAreas.length > 0 ? changedAreas.map((item) => `- \`${item}\``).join('\n') : '- No changed files recorded.'}
+
+## Latest Work Log
+${workLogContent.trim()}
+
+## Unresolved Reflections
+${unresolvedReflections.length > 0 ? unresolvedReflections.map((item) => `- ${item}`).join('\n') : '- No unresolved reflections recorded.'}
+
+## Overall Progress
+- Completion checklist: ${checklist.complete}/${checklist.total}
+- Canonical context lives in \`.ai/*\`.
+- XML bundle generated at \`.ai/report-full.xml\` for parsable handoff.
+`
+
+await writeTextFile(fullReportPath, fullReport)
+if (!shouldSkipXml) {
+  await runRepomix(rootDir)
+}
+process.stderr.write(`Generated ${fullReportPath}\n`)
+
+if (!shouldSkipXml) {
+  process.stderr.write(`Generated ${xmlReportPath}\n`)
+}
+
+async function runRepomix(cwd) {
+  const command =
+    process.platform === 'win32'
+      ? 'pnpm.cmd dlx repomix --include ".ai/current-task.md,.ai/session-handoff.md,.ai/work-log.md,.ai/changed-files.md,.ai/decisions.md,.ai/reflection-log.md,.ai/memory-config.json,AGENTS.md" --output .ai/report-full.xml --style xml --parsable-style --no-default-patterns'
+      : 'pnpm dlx repomix --include ".ai/current-task.md,.ai/session-handoff.md,.ai/work-log.md,.ai/changed-files.md,.ai/decisions.md,.ai/reflection-log.md,.ai/memory-config.json,AGENTS.md" --output .ai/report-full.xml --style xml --parsable-style --no-default-patterns'
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, [], {
+      cwd,
+      shell: true,
+      stdio: 'inherit',
+    })
+
+    child.on('error', reject)
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve()
+        return
+      }
+
+      reject(new Error(`repomix exited with code ${code ?? 'unknown'}`))
+    })
+  })
+}

package/scripts/ai-task-classify.mjs

@@ -0,0 +1,236 @@
+import { execFile } from 'node:child_process'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { promisify } from 'node:util'
+
+import { getRiskMatches, normalizeRepoPath, readMemoryConfig } from './ai-memory-config.mjs'
+import { getArgValue, parseCliArgs, writeAceBanner } from './ai-memory-utils.mjs'
+
+const execFileAsync = promisify(execFile)
+const TIER_RANK = {
+  small: 0,
+  standard: 1,
+  large: 2,
+}
+
+export async function classifyRepositoryTask(rootDir, options = {}) {
+  const [changedFiles, diffStats, diffText, config] = await Promise.all([
+    getChangedFiles(rootDir),
+    getDiffStats(rootDir),
+    getDiffText(rootDir),
+    readMemoryConfig(rootDir),
+  ])
+
+  return classifyTask({
+    changedFiles,
+    config,
+    diffLineCount: diffStats.diffLineCount,
+    diffText,
+    overrideReason: options.overrideReason,
+    overrideTier: options.overrideTier,
+  })
+}
+
+export function classifyTask({
+  changedFiles,
+  config,
+  diffLineCount,
+  diffText = '',
+  overrideReason,
+  overrideTier,
+}) {
+  const normalizedFiles = [...new Set(changedFiles.map(normalizeRepoPath))].sort()
+  const riskMatches = getRiskMatches({
+    changedFiles: normalizedFiles,
+    config,
+    diffText,
+  })
+  const reasons = []
+  let detectedTier = getBaselineTier(normalizedFiles.length, diffLineCount, config)
+
+  if (normalizedFiles.length === 0 && diffLineCount === 0) {
+    reasons.push('No working-tree changes detected.')
+  } else {
+    reasons.push(`${normalizedFiles.length} changed file(s), ${diffLineCount} diff line(s).`)
+  }
+
+  for (const match of riskMatches) {
+    detectedTier = maxTier(detectedTier, match.tier)
+    reasons.push(`${match.label} risk matched ${match.kind} rule \`${match.pattern}\`.`)
+  }
+
+  const finalTier = applyOverride(detectedTier, overrideTier, overrideReason)
+  const designReviewRequired =
+    finalTier === 'large' || riskMatches.some((match) => match.requiresDesignReview)
+
+  if (overrideTier && overrideTier !== detectedTier) {
+    reasons.push(`Override selected \`${overrideTier}\`: ${overrideReason}`)
+  }
+
+  return {
+    changedFiles: normalizedFiles,
+    detectedTier,
+    designReviewRequired,
+    diffLineCount,
+    reasons,
+    requiredWorkflow: getRequiredWorkflow(finalTier, designReviewRequired),
+    riskMatches,
+    tier: finalTier,
+  }
+}
+
+export function getRequiredWorkflow(tier, designReviewRequired) {
+  const workflow = [
+    'Update .ai/session-handoff.md with latest state.',
+    'Update .ai/changed-files.md for touched areas.',
+    'Append a compact .ai/work-log.md entry.',
+    'Generate pnpm ace:report:brief.',
+  ]
+
+  if (tier === 'standard' || tier === 'large') {
+    workflow.push('Fill product, architecture, security, and code-quality review notes.')
+  }
+
+  if (designReviewRequired) {
+    workflow.unshift('Complete .ai/current-task.md Technical Approach before coding.')
+  }
+
+  if (tier === 'large') {
+    workflow.push('Maintain lifecycle goal fields and archive a final task snapshot.')
+    workflow.push(
+      'Review .ai/tech-docs.md or .ai/product-roadmap.md when technical or business state changed.',
+    )
+    workflow.push('Add a reflection entry when the task exposes friction or repeated mistakes.')
+    workflow.push('Generate pnpm ace:report.')
+  }
+
+  return workflow
+}
+
+export function formatClassification(classification) {
+  return [
+    'AI task classification',
+    `Tier: ${classification.tier}`,
+    `Detected tier: ${classification.detectedTier}`,
+    `Design review required: ${classification.designReviewRequired ? 'yes' : 'no'}`,
+    '',
+    'Reasons:',
+    ...classification.reasons.map((reason) => `- ${reason}`),
+    '',
+    'Required workflow:',
+    ...classification.requiredWorkflow.map((item) => `- ${item}`),
+  ].join('\n')
+}
+
+async function getChangedFiles(rootDir) {
+  const output = await gitOutput(rootDir, ['status', '--porcelain'])
+
+  return output
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .map((line) => line.slice(3).trim())
+    .map((filePath) => filePath.split(' -> ').at(-1) ?? filePath)
+    .map(normalizeRepoPath)
+    .filter(Boolean)
+}
+
+async function getDiffStats(rootDir) {
+  const output = await gitOutput(rootDir, ['diff', '--numstat', 'HEAD', '--'])
+  let diffLineCount = 0
+
+  for (const line of output.split('\n')) {
+    const [added, removed] = line.split('\t')
+    const addedLines = Number.parseInt(added, 10)
+    const removedLines = Number.parseInt(removed, 10)
+
+    if (Number.isFinite(addedLines)) {
+      diffLineCount += addedLines
+    }
+
+    if (Number.isFinite(removedLines)) {
+      diffLineCount += removedLines
+    }
+  }
+
+  return { diffLineCount }
+}
+
+async function getDiffText(rootDir) {
+  return gitOutput(rootDir, ['diff', '--unified=0', 'HEAD', '--'])
+}
+
+async function gitOutput(rootDir, args) {
+  try {
+    const result = await execFileAsync('git', args, {
+      cwd: rootDir,
+      encoding: 'utf8',
+      maxBuffer: 20 * 1024 * 1024,
+    })
+
+    return result.stdout
+  } catch {
+    return ''
+  }
+}
+
+function getBaselineTier(fileCount, diffLineCount, config) {
+  if (
+    fileCount <= config.thresholds.small.maxFiles &&
+    diffLineCount <= config.thresholds.small.maxDiffLines
+  ) {
+    return 'small'
+  }
+
+  if (
+    fileCount >= config.thresholds.large.minFiles ||
+    diffLineCount >= config.thresholds.large.minDiffLines
+  ) {
+    return 'large'
+  }
+
+  return 'standard'
+}
+
+function maxTier(left, right) {
+  return TIER_RANK[right] > TIER_RANK[left] ? right : left
+}
+
+function applyOverride(detectedTier, overrideTier, overrideReason) {
+  if (!overrideTier) {
+    return detectedTier
+  }
+
+  if (!(overrideTier in TIER_RANK)) {
+    throw new Error(`Invalid override tier: ${overrideTier}`)
+  }
+
+  if (overrideTier !== detectedTier && !overrideReason) {
+    throw new Error('Task tier override requires --reason.')
+  }
+
+  return overrideTier
+}
+
+async function main() {
+  writeAceBanner()
+
+  const rawArgs = process.argv.slice(2)
+  const args = parseCliArgs(rawArgs)
+  const rootDir = path.resolve(process.cwd(), getArgValue(args, 'root') ?? '.')
+  const classification = await classifyRepositoryTask(rootDir, {
+    overrideReason: getArgValue(args, 'reason'),
+    overrideTier: getArgValue(args, 'tier'),
+  })
+
+  if (getArgValue(args, 'json') === 'true') {
+    process.stdout.write(`${JSON.stringify(classification, null, 2)}\n`)
+    return
+  }
+
+  process.stdout.write(`${formatClassification(classification)}\n`)
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main()
+}