@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/memory/cli.js

@@ -0,0 +1,166 @@
+/**
+ * Memory CLI — `aiwg memory <subcommand>`
+ *
+ * Thin subsystem wrapper around `runSubsystemCli('memory', ...)` for
+ * the `memory` storage subsystem. Subcommands and behavior live in
+ * `src/storage/subsystem-cli.ts` so memory and reflections share the
+ * same implementation.
+ *
+ * @issue #934
+ * @issue #966
+ */
+import { runSubsystemCli } from '../storage/subsystem-cli.js';
+export async function main(args) {
+    if (args[0] === 'project') {
+        await runProjectMemoryCli(args.slice(1));
+        return;
+    }
+    await runSubsystemCli('memory', args);
+}
+async function runProjectMemoryCli(args) {
+    const subcommand = args[0];
+    const rest = args.slice(1);
+    const json = rest.includes('--json');
+    const registry = await import('./project-registry.js');
+    switch (subcommand) {
+        case 'register': {
+            const opts = parseProjectMemoryOptions(rest);
+            const entry = await registry.registerProjectMemory({
+                workspaceRoot: opts.workspace,
+                id: opts.id,
+                name: opts.name,
+                memoryRoot: opts.memoryRoot,
+            });
+            if (json)
+                console.log(JSON.stringify(entry, null, 2));
+            else {
+                console.log(`Registered project memory: ${entry.id}`);
+                console.log(`  workspace: ${entry.workspaceRoots.join(', ')}`);
+                console.log(`  memory:    ${entry.memoryRoot}`);
+            }
+            break;
+        }
+        case 'inspect':
+        case 'resolve': {
+            const opts = parseProjectMemoryOptions(rest);
+            if (subcommand === 'resolve') {
+                const resolved = await registry.resolveProjectMemoryRoot(opts.workspace ?? process.cwd());
+                if (json)
+                    console.log(JSON.stringify(resolved, null, 2));
+                else {
+                    console.log(resolved.root);
+                    console.log(`source: ${resolved.source} (${resolved.reason})`);
+                }
+                break;
+            }
+            const lookup = await registry.lookupProjectMemory({
+                id: opts.id,
+                workspaceRoot: opts.workspace ?? (!opts.id && !opts.remote ? process.cwd() : undefined),
+                gitRemote: opts.remote,
+            });
+            if (json)
+                console.log(JSON.stringify(lookup, null, 2));
+            else
+                printLookup(lookup);
+            break;
+        }
+        case 'list': {
+            const manifest = await registry.readProjectMemoryManifest();
+            if (json)
+                console.log(JSON.stringify(manifest.projects, null, 2));
+            else if (manifest.projects.length === 0)
+                console.log('No registered project memory entries.');
+            else
+                for (const entry of manifest.projects)
+                    console.log(`${entry.id}\t${entry.name}\t${entry.memoryRoot}`);
+            break;
+        }
+        case 'reindex': {
+            const index = await registry.writeProjectMemoryIndex();
+            if (json)
+                console.log(JSON.stringify(index, null, 2));
+            else
+                console.log(`Reindexed ${Object.keys(index.byProjectId).length} project memory entr${Object.keys(index.byProjectId).length === 1 ? 'y' : 'ies'} at ${registry.projectMemoryIndexPath()}`);
+            break;
+        }
+        case 'relocate': {
+            const id = rest.find((arg) => !arg.startsWith('--'));
+            const target = rest.filter((arg) => !arg.startsWith('--'))[1];
+            if (!id || !target)
+                throw new Error('Usage: aiwg memory project relocate <id> <memory-root> [--json]');
+            const entry = await registry.relocateProjectMemory(id, target);
+            if (json)
+                console.log(JSON.stringify(entry, null, 2));
+            else
+                console.log(`Relocated ${entry.id} to ${entry.memoryRoot}`);
+            break;
+        }
+        case 'remove': {
+            const id = rest.find((arg) => !arg.startsWith('--'));
+            if (!id)
+                throw new Error('Usage: aiwg memory project remove <id> [--delete-files] [--json]');
+            const removed = await registry.removeProjectMemory(id, { deleteFiles: rest.includes('--delete-files') });
+            if (json)
+                console.log(JSON.stringify({ removed }, null, 2));
+            else
+                console.log(removed ? `Removed project memory mapping: ${removed.id}` : `No project memory mapping found for: ${id}`);
+            break;
+        }
+        default:
+            printProjectMemoryUsage();
+            if (subcommand)
+                throw new Error(`Unknown memory project subcommand: ${subcommand}`);
+    }
+}
+function parseProjectMemoryOptions(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--id')
+            opts.id = args[++i];
+        else if (arg === '--name')
+            opts.name = args[++i];
+        else if (arg === '--workspace')
+            opts.workspace = args[++i];
+        else if (arg === '--remote')
+            opts.remote = args[++i];
+        else if (arg === '--memory-root')
+            opts.memoryRoot = args[++i];
+    }
+    return opts;
+}
+function printLookup(lookup) {
+    if (lookup.status === 'missing') {
+        console.log(`No project memory mapping found: ${lookup.reason}`);
+        return;
+    }
+    if (lookup.status === 'ambiguous') {
+        console.log(lookup.reason);
+        for (const entry of lookup.entries)
+            console.log(`  ${entry.id}\t${entry.memoryRoot}`);
+        return;
+    }
+    console.log(`Project memory: ${lookup.entry.id}`);
+    console.log(`  matched by: ${lookup.matchedBy}`);
+    console.log(`  name:       ${lookup.entry.name}`);
+    console.log(`  memory:     ${lookup.entry.memoryRoot}`);
+    console.log(`  workspace:  ${lookup.entry.workspaceRoots.join(', ')}`);
+    if (lookup.entry.gitRemotes.length > 0)
+        console.log(`  remotes:    ${lookup.entry.gitRemotes.join(', ')}`);
+}
+function printProjectMemoryUsage() {
+    console.log(`Usage: aiwg memory project <subcommand>
+
+Subcommands:
+  register [--id <id>] [--name <name>] [--workspace <path>] [--memory-root <path>] [--json]
+  inspect [--id <id> | --workspace <path> | --remote <url>] [--json]
+  resolve [--workspace <path>] [--json]
+  list [--json]
+  reindex [--json]
+  relocate <id> <memory-root> [--json]
+  remove <id> [--delete-files] [--json]
+
+The manifest lives at ~/.aiwg/projects/manifest.json and each registered
+project memory root uses a private .aiwg layout under ~/.aiwg/projects/<id>/.aiwg.`);
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/memory/project-registry.js

@@ -0,0 +1,282 @@
+/**
+ * User-level project memory registry (#1750).
+ *
+ * Stores private, per-project AIWG memory roots under ~/.aiwg/projects while
+ * preserving the effective `.aiwg` layout inside each registered memory root.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { projectAiwgPath, resolveProjectAiwgDir } from '../config/project-artifacts.js';
+export function projectMemoryHome() {
+    const override = process.env.AIWG_PROJECT_MEMORY_HOME;
+    if (override)
+        return path.resolve(override);
+    return path.join(homedir(), '.aiwg', 'projects');
+}
+export function projectMemoryManifestPath() {
+    return path.join(projectMemoryHome(), 'manifest.json');
+}
+export function projectMemoryIndexPath() {
+    return path.join(projectMemoryHome(), 'index', 'manifest-index.json');
+}
+export function emptyProjectMemoryManifest() {
+    return { version: 1, projects: [] };
+}
+export async function readProjectMemoryManifest() {
+    const manifestPath = projectMemoryManifestPath();
+    if (!existsSync(manifestPath))
+        return emptyProjectMemoryManifest();
+    const parsed = JSON.parse(await readFile(manifestPath, 'utf-8'));
+    if (parsed.version !== 1 || !Array.isArray(parsed.projects)) {
+        throw new Error(`${manifestPath}: expected project memory manifest version 1`);
+    }
+    return {
+        version: 1,
+        projects: parsed.projects.map(normalizeEntry),
+    };
+}
+export async function writeProjectMemoryManifest(manifest) {
+    const manifestPath = projectMemoryManifestPath();
+    await mkdir(path.dirname(manifestPath), { recursive: true });
+    const normalized = {
+        version: 1,
+        projects: [...manifest.projects].sort((a, b) => a.id.localeCompare(b.id)).map(normalizeEntry),
+    };
+    await writeFile(manifestPath, JSON.stringify(normalized, null, 2) + '\n', 'utf-8');
+    await writeProjectMemoryIndex(normalized);
+}
+export async function writeProjectMemoryIndex(manifest) {
+    manifest ??= await readProjectMemoryManifest();
+    const index = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        byProjectId: {},
+        byWorkspaceRoot: {},
+        byGitRemote: {},
+    };
+    for (const entry of manifest.projects) {
+        index.byProjectId[entry.id] = entry.id;
+        for (const root of entry.workspaceRoots) {
+            addIndexValue(index.byWorkspaceRoot, normalizeWorkspaceRoot(root), entry.id);
+        }
+        for (const remote of entry.gitRemotes) {
+            addIndexValue(index.byGitRemote, normalizeGitRemote(remote), entry.id);
+        }
+    }
+    const indexPath = projectMemoryIndexPath();
+    await mkdir(path.dirname(indexPath), { recursive: true });
+    await writeFile(indexPath, JSON.stringify(index, null, 2) + '\n', 'utf-8');
+    return index;
+}
+export async function registerProjectMemory(opts) {
+    const workspaceRoot = normalizeWorkspaceRoot(opts.workspaceRoot ?? process.cwd());
+    const gitRemotes = uniqueGitRemotes(opts.gitRemotes ?? discoverGitRemotes(workspaceRoot));
+    const name = opts.name ?? path.basename(workspaceRoot);
+    const metadata = { ...metadataFromRemotes(gitRemotes), ...opts.metadata };
+    const id = sanitizeProjectId(opts.id ?? stableProjectId({ name, workspaceRoot, gitRemotes }));
+    const now = new Date().toISOString();
+    const memoryRoot = expandUserPath(opts.memoryRoot ?? path.join(projectMemoryHome(), id, '.aiwg'));
+    const manifest = await readProjectMemoryManifest();
+    const existing = manifest.projects.find((p) => p.id === id);
+    const entry = {
+        id,
+        name,
+        workspaceRoots: normalizeUnique([...(existing?.workspaceRoots ?? []), workspaceRoot], normalizeWorkspaceRoot),
+        gitRemotes: uniqueGitRemotes([...(existing?.gitRemotes ?? []), ...gitRemotes]),
+        memoryRoot,
+        metadata,
+        registeredAt: existing?.registeredAt ?? now,
+        updatedAt: now,
+    };
+    const nextProjects = manifest.projects.filter((p) => p.id !== id);
+    nextProjects.push(entry);
+    await ensureMemoryLayout(entry.memoryRoot);
+    await writeProjectMemoryManifest({ version: 1, projects: nextProjects });
+    return entry;
+}
+export async function lookupProjectMemory(opts) {
+    const manifest = await readProjectMemoryManifest();
+    if (opts.id) {
+        const entry = manifest.projects.find((p) => p.id === opts.id);
+        return entry
+            ? { status: 'found', entry, matchedBy: 'id' }
+            : { status: 'missing', reason: `No project memory entry with id '${opts.id}'` };
+    }
+    if (opts.workspaceRoot) {
+        const active = normalizeWorkspaceRoot(opts.workspaceRoot);
+        const matches = manifest.projects
+            .filter((p) => p.workspaceRoots.some((root) => isWithinRoot(active, normalizeWorkspaceRoot(root))))
+            .sort((a, b) => longestMatchingRoot(b, active) - longestMatchingRoot(a, active));
+        const topLen = matches.length > 0 ? longestMatchingRoot(matches[0], active) : -1;
+        const top = matches.filter((p) => longestMatchingRoot(p, active) === topLen);
+        if (top.length === 1)
+            return { status: 'found', entry: top[0], matchedBy: 'workspaceRoot' };
+        if (top.length > 1)
+            return { status: 'ambiguous', reason: `Multiple project memory entries match workspace '${active}'`, entries: top };
+    }
+    if (opts.gitRemote) {
+        const remote = normalizeGitRemote(opts.gitRemote);
+        const matches = manifest.projects.filter((p) => p.gitRemotes.map(normalizeGitRemote).includes(remote));
+        if (matches.length === 1)
+            return { status: 'found', entry: matches[0], matchedBy: 'gitRemote' };
+        if (matches.length > 1)
+            return { status: 'ambiguous', reason: `Multiple project memory entries match remote '${opts.gitRemote}'`, entries: matches };
+    }
+    return { status: 'missing', reason: 'No project memory entry matched the supplied workspace or remote metadata' };
+}
+export async function resolveProjectMemoryRoot(projectRoot = process.cwd()) {
+    const localAiwg = resolveProjectAiwgDir(projectRoot);
+    if (existsSync(localAiwg)) {
+        return { source: 'project-local', root: path.join(localAiwg, 'memory'), reason: 'configured project AIWG artifact root exists' };
+    }
+    const byPath = await lookupProjectMemory({ workspaceRoot: projectRoot });
+    if (byPath.status === 'found') {
+        return { source: 'user', root: path.join(byPath.entry.memoryRoot, 'memory'), entry: byPath.entry, reason: 'matched workspace path' };
+    }
+    if (byPath.status === 'ambiguous') {
+        return { source: 'default', root: projectAiwgPath(projectRoot, 'memory'), reason: byPath.reason };
+    }
+    for (const remote of discoverGitRemotes(projectRoot)) {
+        const byRemote = await lookupProjectMemory({ gitRemote: remote });
+        if (byRemote.status === 'found') {
+            return { source: 'user', root: path.join(byRemote.entry.memoryRoot, 'memory'), entry: byRemote.entry, reason: 'matched git remote' };
+        }
+        if (byRemote.status === 'ambiguous') {
+            return { source: 'default', root: projectAiwgPath(projectRoot, 'memory'), reason: byRemote.reason };
+        }
+    }
+    return { source: 'default', root: projectAiwgPath(projectRoot, 'memory'), reason: 'no registered user-level project memory entry' };
+}
+export async function relocateProjectMemory(id, newMemoryRoot) {
+    const manifest = await readProjectMemoryManifest();
+    const entry = manifest.projects.find((p) => p.id === id);
+    if (!entry)
+        throw new Error(`No project memory entry with id '${id}'`);
+    const oldRoot = entry.memoryRoot;
+    const nextRoot = expandUserPath(newMemoryRoot);
+    if (oldRoot !== nextRoot && existsSync(oldRoot) && !existsSync(nextRoot)) {
+        await mkdir(path.dirname(nextRoot), { recursive: true });
+        await rename(oldRoot, nextRoot);
+    }
+    else {
+        await ensureMemoryLayout(nextRoot);
+    }
+    entry.memoryRoot = nextRoot;
+    entry.updatedAt = new Date().toISOString();
+    await writeProjectMemoryManifest(manifest);
+    return entry;
+}
+export async function removeProjectMemory(id, opts = {}) {
+    const manifest = await readProjectMemoryManifest();
+    const entry = manifest.projects.find((p) => p.id === id);
+    if (!entry)
+        return null;
+    await writeProjectMemoryManifest({ version: 1, projects: manifest.projects.filter((p) => p.id !== id) });
+    if (opts.deleteFiles)
+        await rm(entry.memoryRoot, { recursive: true, force: true });
+    return entry;
+}
+export async function ensureMemoryLayout(memoryRoot) {
+    await mkdir(path.join(memoryRoot, 'memory'), { recursive: true });
+    await mkdir(path.join(memoryRoot, 'index'), { recursive: true });
+    await mkdir(path.join(memoryRoot, 'artifacts'), { recursive: true });
+    const configPath = path.join(memoryRoot, 'aiwg.config');
+    if (!existsSync(configPath)) {
+        await writeFile(configPath, JSON.stringify({ version: '1', projectMemory: { private: true } }, null, 2) + '\n', 'utf-8');
+    }
+}
+export function normalizeGitRemote(remote) {
+    const trimmed = remote.trim();
+    const withoutGit = trimmed.endsWith('.git') ? trimmed.slice(0, -4) : trimmed;
+    const ssh = withoutGit.match(/^git@([^:]+):(.+)$/);
+    if (ssh)
+        return `${ssh[1].toLowerCase()}/${ssh[2].replace(/^\/+/, '').toLowerCase()}`;
+    try {
+        const u = new URL(withoutGit);
+        return `${u.hostname.toLowerCase()}/${u.pathname.replace(/^\/+/, '').replace(/\/+$/, '').toLowerCase()}`;
+    }
+    catch {
+        return withoutGit.toLowerCase();
+    }
+}
+function normalizeEntry(entry) {
+    return {
+        ...entry,
+        workspaceRoots: normalizeUnique(entry.workspaceRoots ?? [], normalizeWorkspaceRoot),
+        gitRemotes: uniqueGitRemotes(entry.gitRemotes ?? []),
+        memoryRoot: expandUserPath(entry.memoryRoot),
+        metadata: entry.metadata ?? {},
+    };
+}
+function addIndexValue(index, key, id) {
+    index[key] = Array.from(new Set([...(index[key] ?? []), id])).sort();
+}
+function normalizeUnique(values, normalize) {
+    return Array.from(new Set(values.filter(Boolean).map(normalize))).sort();
+}
+function uniqueGitRemotes(values) {
+    const byNormalized = new Map();
+    for (const value of values.filter(Boolean)) {
+        const trimmed = value.trim();
+        const normalized = normalizeGitRemote(trimmed);
+        if (!byNormalized.has(normalized))
+            byNormalized.set(normalized, trimmed);
+    }
+    return Array.from(byNormalized.values()).sort();
+}
+function normalizeWorkspaceRoot(root) {
+    return path.resolve(expandUserPath(root));
+}
+function expandUserPath(value) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/'))
+        return path.join(homedir(), value.slice(2));
+    return path.resolve(value);
+}
+function stableProjectId(opts) {
+    const seed = opts.gitRemotes[0] ? normalizeGitRemote(opts.gitRemotes[0]) : opts.workspaceRoot;
+    const digest = createHash('sha256').update(seed).digest('hex').slice(0, 12);
+    return `${opts.name}-${digest}`;
+}
+function sanitizeProjectId(id) {
+    return id.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
+}
+function discoverGitRemotes(cwd) {
+    try {
+        const stdout = execFileSync('git', ['remote', '-v'], { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const remotes = stdout
+            .split('\n')
+            .map((line) => line.trim().split(/\s+/)[1])
+            .filter((remote) => Boolean(remote));
+        return normalizeUnique(remotes, (v) => v.trim());
+    }
+    catch {
+        return [];
+    }
+}
+function metadataFromRemotes(remotes) {
+    for (const remote of remotes) {
+        const normalized = normalizeGitRemote(remote);
+        const parts = normalized.split('/');
+        if (parts.length >= 3) {
+            return { owner: parts[parts.length - 2], repo: parts[parts.length - 1] };
+        }
+    }
+    return {};
+}
+function isWithinRoot(active, root) {
+    const rel = path.relative(root, active);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+function longestMatchingRoot(entry, active) {
+    return Math.max(...entry.workspaceRoots.map((root) => {
+        const normalized = normalizeWorkspaceRoot(root);
+        return isWithinRoot(active, normalized) ? normalized.length : -1;
+    }));
+}
+//# sourceMappingURL=project-registry.js.map

package/dist/src/metrics/artifact-metrics.js

@@ -0,0 +1,184 @@
+/**
+ * Artifact Metrics — record and query per-artifact token metrics
+ *
+ * Hooks into artifact save events, records path/type/agent/timestamp/tokens,
+ * and persists to `.aiwg/metrics/tokens/`.
+ *
+ * @module metrics/artifact-metrics
+ * @issue #173
+ * @schema @agentic/code/frameworks/sdlc-complete/schemas/flows/token-efficiency.yaml
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { countTokens, evaluateThreshold, BENCHMARK_TOKENS_PER_LINE, BASELINE_TOKENS_PER_LINE, } from './token-counter.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const METRICS_DIR = '.aiwg/metrics/tokens';
+const RECORDS_FILE = 'records.json';
+// ============================================================================
+// ArtifactMetricsStore
+// ============================================================================
+export class ArtifactMetricsStore {
+    projectPath;
+    metricsDir;
+    records;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.metricsDir = path.join(projectPath, METRICS_DIR);
+        this.records = [];
+    }
+    /**
+     * Record metrics for an artifact after save.
+     */
+    async recordArtifact(artifactPath, content, artifactType, agent) {
+        const tokenCount = countTokens(content);
+        const threshold = evaluateThreshold(tokenCount.tokensPerLine);
+        const relativePath = path.isAbsolute(artifactPath)
+            ? path.relative(this.projectPath, artifactPath)
+            : artifactPath;
+        const record = {
+            artifactPath: relativePath,
+            artifactType,
+            agent,
+            timestamp: new Date().toISOString(),
+            tokens: {
+                totalTokens: tokenCount.tokens,
+                nonBlankLines: tokenCount.nonBlankLines,
+                tokensPerLine: tokenCount.tokensPerLine,
+                characters: tokenCount.characters,
+            },
+            thresholdStatus: threshold.level,
+        };
+        this.records.push(record);
+        await this.persist();
+        return record;
+    }
+    /**
+     * Query records with optional filters.
+     */
+    queryRecords(options = {}) {
+        let filtered = [...this.records];
+        if (options.agent) {
+            const agentLower = options.agent.toLowerCase();
+            filtered = filtered.filter((r) => r.agent.toLowerCase() === agentLower);
+        }
+        if (options.since) {
+            const sinceDate = parseSinceDate(options.since);
+            if (sinceDate) {
+                filtered = filtered.filter((r) => new Date(r.timestamp) >= sinceDate);
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Get per-agent efficiency summaries.
+     */
+    getAgentSummaries(options = {}) {
+        const records = this.queryRecords(options);
+        const byAgent = new Map();
+        for (const record of records) {
+            const existing = byAgent.get(record.agent) || [];
+            existing.push(record);
+            byAgent.set(record.agent, existing);
+        }
+        const summaries = [];
+        for (const [agentName, agentRecords] of byAgent) {
+            const totalTokens = agentRecords.reduce((sum, r) => sum + r.tokens.totalTokens, 0);
+            const totalLines = agentRecords.reduce((sum, r) => sum + r.tokens.nonBlankLines, 0);
+            const avgTokensPerLine = totalLines > 0 ? totalTokens / totalLines : 0;
+            const tokensPerLineValues = agentRecords.map((r) => r.tokens.tokensPerLine);
+            const minTokensPerLine = Math.min(...tokensPerLineValues);
+            const maxTokensPerLine = Math.max(...tokensPerLineValues);
+            const vsBenchmark = avgTokensPerLine > 0
+                ? ((avgTokensPerLine - BENCHMARK_TOKENS_PER_LINE) / BENCHMARK_TOKENS_PER_LINE) * 100
+                : 0;
+            const vsBaseline = avgTokensPerLine > 0
+                ? ((avgTokensPerLine - BASELINE_TOKENS_PER_LINE) / BASELINE_TOKENS_PER_LINE) * 100
+                : 0;
+            const threshold = evaluateThreshold(avgTokensPerLine);
+            const trend = calculateTrend(agentRecords);
+            summaries.push({
+                agentName,
+                period: options.since || 'all-time',
+                totalArtifacts: agentRecords.length,
+                totalTokens,
+                totalLines,
+                avgTokensPerLine: Math.round(avgTokensPerLine * 100) / 100,
+                minTokensPerLine: Math.round(minTokensPerLine * 100) / 100,
+                maxTokensPerLine: Math.round(maxTokensPerLine * 100) / 100,
+                vsBenchmark: Math.round(vsBenchmark * 100) / 100,
+                vsBaseline: Math.round(vsBaseline * 100) / 100,
+                trend,
+                thresholdStatus: threshold.level,
+            });
+        }
+        return summaries;
+    }
+    /**
+     * Load records from disk.
+     */
+    async load() {
+        try {
+            const filePath = path.join(this.metricsDir, RECORDS_FILE);
+            const content = await fs.readFile(filePath, 'utf-8');
+            this.records = JSON.parse(content);
+        }
+        catch {
+            this.records = [];
+        }
+    }
+    /**
+     * Persist records to disk.
+     */
+    async persist() {
+        try {
+            await fs.mkdir(this.metricsDir, { recursive: true });
+            const filePath = path.join(this.metricsDir, RECORDS_FILE);
+            await fs.writeFile(filePath, JSON.stringify(this.records, null, 2), 'utf-8');
+        }
+        catch {
+            // Silently fail persistence — metrics are non-critical
+        }
+    }
+    /**
+     * Get all records (for testing).
+     */
+    getAllRecords() {
+        return [...this.records];
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function parseSinceDate(since) {
+    const durationMatch = since.match(/^(\d+)d$/);
+    if (durationMatch) {
+        const days = parseInt(durationMatch[1], 10);
+        const date = new Date();
+        date.setDate(date.getDate() - days);
+        return date;
+    }
+    const parsed = new Date(since);
+    if (!isNaN(parsed.getTime())) {
+        return parsed;
+    }
+    return null;
+}
+function calculateTrend(records) {
+    if (records.length < 4)
+        return 'stable';
+    const sorted = [...records].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const midpoint = Math.floor(sorted.length / 2);
+    const firstHalf = sorted.slice(0, midpoint);
+    const secondHalf = sorted.slice(midpoint);
+    const avgFirst = firstHalf.reduce((sum, r) => sum + r.tokens.tokensPerLine, 0) / firstHalf.length;
+    const avgSecond = secondHalf.reduce((sum, r) => sum + r.tokens.tokensPerLine, 0) / secondHalf.length;
+    const changePercent = ((avgSecond - avgFirst) / avgFirst) * 100;
+    if (changePercent < -5)
+        return 'improving';
+    if (changePercent > 5)
+        return 'degrading';
+    return 'stable';
+}
+//# sourceMappingURL=artifact-metrics.js.map