@webpresso/agent-kit 0.21.0

package/dist/esm/output-transforms/passthrough.d.ts

@@ -0,0 +1,3 @@
+import type { TransformContext, TransformResult } from './index.js';
+export declare function passthroughTransform(rawOutput: string | undefined, context: TransformContext): TransformResult;
+//# sourceMappingURL=passthrough.d.ts.map

package/dist/esm/output-transforms/passthrough.js

@@ -0,0 +1,11 @@
+import { createTransformResult } from './metadata.js';
+export function passthroughTransform(rawOutput, context) {
+    if (!rawOutput)
+        return {};
+    return createTransformResult(rawOutput, rawOutput, context, {
+        tier: 3,
+        failures: [],
+        legacyTier: 'passthrough',
+    });
+}
+//# sourceMappingURL=passthrough.js.map

package/dist/esm/output-transforms/rulesync.d.ts

@@ -0,0 +1,3 @@
+import type { TransformContext, TransformResult } from './index.js';
+export declare function rulesyncTransform(rawOutput: string | undefined, context: TransformContext): TransformResult;
+//# sourceMappingURL=rulesync.d.ts.map

package/dist/esm/output-transforms/rulesync.js

@@ -0,0 +1,80 @@
+import { createTransformResult } from './metadata.js';
+import { passthroughTransform } from './passthrough.js';
+const MAX_OUTPUT_BYTES = 4_000;
+// Matches: ✓ Claude Code: 3 skills, 2 commands, 1 agent
+const SUCCESS_LINE_RE = /^[✓✔]\s+([\w\s]+?):\s+(\d+)\s+skills?,\s+(\d+)\s+commands?,\s+(\d+)\s+agents?/u;
+// Matches: ✗ Cursor: failed to write .cursor/rules/foo.md: EACCES
+const FAILURE_LINE_RE = /^[✗✘]\s+([\w\s]+?):\s+(.+)$/u;
+// Summary line: Generated in 120ms
+const SUMMARY_LINE_RE = /^Generated in \d+ms$/u;
+function parseRulesyncOutput(raw) {
+    const targets = [];
+    let hasSummaryLine = false;
+    for (const line of raw.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (SUMMARY_LINE_RE.test(trimmed)) {
+            hasSummaryLine = true;
+            continue;
+        }
+        const successMatch = SUCCESS_LINE_RE.exec(trimmed);
+        if (successMatch) {
+            targets.push({
+                target: successMatch[1]?.trim() ?? '',
+                skills: parseInt(successMatch[2] ?? '0', 10),
+                commands: parseInt(successMatch[3] ?? '0', 10),
+                agents: parseInt(successMatch[4] ?? '0', 10),
+                failed: false,
+            });
+            continue;
+        }
+        const failureMatch = FAILURE_LINE_RE.exec(trimmed);
+        if (failureMatch) {
+            targets.push({
+                target: failureMatch[1]?.trim() ?? '',
+                skills: 0,
+                commands: 0,
+                agents: 0,
+                failed: true,
+                failureDetail: failureMatch[2]?.trim(),
+            });
+        }
+    }
+    return { targets, hasSummaryLine };
+}
+function buildSummaryLine(targets) {
+    const total = targets.length;
+    const failed = targets.filter((t) => t.failed).length;
+    const passed = total - failed;
+    if (failed === 0)
+        return `rulesync: ${passed} target${passed === 1 ? '' : 's'} synced`;
+    return `rulesync: ${passed}/${total} targets synced, ${failed} failed`;
+}
+export function rulesyncTransform(rawOutput, context) {
+    if (!rawOutput)
+        return {};
+    const { targets, hasSummaryLine } = parseRulesyncOutput(rawOutput);
+    if (targets.length === 0 && !hasSummaryLine) {
+        return passthroughTransform(rawOutput, context);
+    }
+    const failures = targets
+        .filter((t) => t.failed)
+        .map((t) => ({
+        message: t.failureDetail ? `${t.target}: ${t.failureDetail}` : `${t.target}: failed`,
+    }));
+    const summaryLine = buildSummaryLine(targets);
+    const successLines = targets
+        .filter((t) => !t.failed)
+        .map((t) => `  ${t.target}: ${t.skills} skills, ${t.commands} commands, ${t.agents} agents`);
+    const failureLines = targets
+        .filter((t) => t.failed)
+        .map((t) => `  ${t.target}: FAILED — ${t.failureDetail ?? 'unknown error'}`);
+    const compactOutput = [summaryLine, ...successLines, ...failureLines].join('\n');
+    // Clip to 4000 bytes via createTransformResult
+    return createTransformResult(rawOutput, compactOutput.slice(0, MAX_OUTPUT_BYTES), context, {
+        tier: 1,
+        failures,
+    });
+}
+//# sourceMappingURL=rulesync.js.map

package/dist/esm/output-transforms/should-compact.d.ts

@@ -0,0 +1,7 @@
+export interface ShouldCompactOptions {
+    readonly flag?: boolean;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly isTTY?: boolean;
+}
+export declare function shouldCompact(options?: ShouldCompactOptions): boolean;
+//# sourceMappingURL=should-compact.d.ts.map

package/dist/esm/output-transforms/should-compact.js

@@ -0,0 +1,14 @@
+export function shouldCompact(options = {}) {
+    if (options.flag !== undefined)
+        return options.flag;
+    const sourceEnv = options.env ?? process.env;
+    const envValue = sourceEnv.QUALITY_ENGINE_COMPACT ?? sourceEnv.WP_COMPACT;
+    if (envValue !== undefined)
+        return parseBooleanEnv(envValue);
+    const isTTY = options.isTTY ?? process.stdout.isTTY ?? false;
+    return !isTTY;
+}
+function parseBooleanEnv(value) {
+    return !['0', 'false', 'no', 'off'].includes(value.trim().toLowerCase());
+}
+//# sourceMappingURL=should-compact.js.map

package/dist/esm/output-transforms/tsc.d.ts

@@ -0,0 +1,3 @@
+import type { TransformContext, TransformResult } from './index.js';
+export declare function tscTransform(rawOutput: string | undefined, context: TransformContext): TransformResult;
+//# sourceMappingURL=tsc.d.ts.map

package/dist/esm/output-transforms/tsc.js

@@ -0,0 +1,45 @@
+import { createTransformResult } from './metadata.js';
+import { passthroughTransform } from './passthrough.js';
+const TSC_ERROR_RE = /^(.+?)(?:\((\d+),\d+\)|:(\d+):\d+)(?::\s*|\s+-\s+)error TS(\d+):\s*(.*)$/gmu;
+export function tscTransform(rawOutput, context) {
+    if (!rawOutput)
+        return {};
+    const errors = parseTscErrors(rawOutput);
+    if (errors.length === 0)
+        return passthroughTransform(rawOutput, context);
+    const byKey = new Map();
+    for (const error of errors) {
+        const key = `${error.file}:${error.line}:TS${error.code}:${error.message}`;
+        const existing = byKey.get(key);
+        if (existing) {
+            byKey.set(key, { ...existing, count: existing.count + 1 });
+        }
+        else {
+            byKey.set(key, { ...error, count: 1 });
+        }
+    }
+    const compactErrors = [...byKey.values()];
+    return createTransformResult(rawOutput, compactErrors
+        .map((error) => {
+        const suffix = error.count > 1 ? ` (x${error.count})` : '';
+        return `${error.file}:${error.line} TS${error.code} ${error.message}${suffix}`;
+    })
+        .join('\n'), context, {
+        tier: 1,
+        failures: compactErrors.map((error) => ({
+            file: error.file,
+            line: error.line,
+            code: `TS${error.code}`,
+            message: error.message,
+        })),
+    });
+}
+function parseTscErrors(output) {
+    return [...output.matchAll(TSC_ERROR_RE)].map((match) => ({
+        file: match[1] ?? '',
+        line: Number(match[2] ?? match[3] ?? 0),
+        code: match[4] ?? '',
+        message: match[5] ?? '',
+    }));
+}
+//# sourceMappingURL=tsc.js.map

package/dist/esm/output-transforms/vitest.d.ts

@@ -0,0 +1,3 @@
+import type { TransformContext, TransformResult } from './index.js';
+export declare function vitestTransform(rawOutput: string | undefined, context: TransformContext): TransformResult;
+//# sourceMappingURL=vitest.d.ts.map

package/dist/esm/output-transforms/vitest.js

@@ -0,0 +1,120 @@
+import { createTransformResult } from './metadata.js';
+import { passthroughTransform } from './passthrough.js';
+export function vitestTransform(rawOutput, context) {
+    if (!rawOutput)
+        return {};
+    const parsed = parseJsonish(rawOutput);
+    if (parsed !== undefined) {
+        const failures = collectFailures(parsed);
+        return compact(rawOutput, context, failures, 1);
+    }
+    const fallback = regexFallback(rawOutput);
+    if (fallback.length > 0)
+        return compact(rawOutput, context, fallback, 2);
+    return passthroughTransform(rawOutput, context);
+}
+function parseJsonish(rawOutput) {
+    const json = extractJson(rawOutput);
+    if (!json)
+        return undefined;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractJson(rawOutput) {
+    const start = rawOutput.search(/[[{]/u);
+    if (start < 0)
+        return undefined;
+    const open = rawOutput[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < rawOutput.length; index += 1) {
+        const char = rawOutput[index];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        if (char === open)
+            depth += 1;
+        if (char === close)
+            depth -= 1;
+        if (depth === 0)
+            return rawOutput.slice(start, index + 1);
+    }
+    return undefined;
+}
+function collectFailures(value) {
+    const failures = [];
+    visit(value, undefined, failures);
+    return failures;
+}
+function visit(value, inheritedFile, failures) {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            visit(item, inheritedFile, failures);
+        return;
+    }
+    const record = value;
+    const file = firstString(record.file, record.filepath, record.filePath, record.name?.toString().endsWith('.ts') ? record.name : undefined) ?? inheritedFile;
+    const status = firstString(record.status, record.state);
+    const failureMessages = Array.isArray(record.failureMessages)
+        ? record.failureMessages.filter((item) => typeof item === 'string')
+        : typeof record.failureMessage === 'string'
+            ? [record.failureMessage]
+            : [];
+    if (status && /fail|failed/iu.test(status) && failureMessages.length > 0) {
+        failures.push({
+            file,
+            name: firstString(record.fullName, record.title, record.name) ?? '<unnamed test>',
+            message: firstStackLine(failureMessages[0] ?? 'failed'),
+        });
+    }
+    for (const item of Object.values(record))
+        visit(item, file, failures);
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === 'string' && value.length > 0);
+}
+function firstStackLine(message) {
+    return (message
+        .split(/\r?\n/u)
+        .find((line) => line.trim().length > 0)
+        ?.trim() ?? message);
+}
+function regexFallback(rawOutput) {
+    return rawOutput
+        .split(/\r?\n/u)
+        .filter((line) => /FAIL|failed|Error:/u.test(line))
+        .slice(0, 20)
+        .map((line) => ({ name: '<summary>', message: line.trim() }));
+}
+function compact(rawOutput, context, failures, tier) {
+    const structuredFailures = failures.map((failure) => ({
+        file: failure.file,
+        message: `${failure.name}: ${failure.message}`,
+    }));
+    return createTransformResult(rawOutput, failures
+        .map((failure) => `${failure.file ? `${failure.file} ` : ''}${failure.name}: ${failure.message}`)
+        .join('\n'), context, {
+        tier,
+        failures: structuredFailures,
+    });
+}
+//# sourceMappingURL=vitest.js.map

package/dist/esm/package.json

@@ -0,0 +1,92 @@
+{
+  "type": "module",
+  "imports": {
+    "#db/*.js": "./blueprint/db/*.js",
+    "#db/*": "./blueprint/db/*.js",
+    "#e2e": "./e2e/index.js",
+    "#e2e/*.js": "./e2e/*.js",
+    "#e2e/*": "./e2e/*.js",
+    "#test": "./test/index.js",
+    "#symlinker": "./symlinker/index.js",
+    "#paths/*.js": "./paths/*.js",
+    "#paths/*": "./paths/*.js",
+    "#cli/auto-update/*.js": "./cli/auto-update/*.js",
+    "#cli/auto-update/*": "./cli/auto-update/*.js",
+    "#cli/*.js": "./cli/*.js",
+    "#cli/*": "./cli/*.js",
+    "#dev/*.js": "./dev/*.js",
+    "#dev/*": "./dev/*.js",
+    "#audit/*.js": "./audit/*.js",
+    "#audit/*": "./audit/*.js",
+    "#docs-linter/*.js": "./docs-linter/*.js",
+    "#docs-linter/*": "./docs-linter/*.js",
+    "#config/tsconfig/*.js": "./config/tsconfig/*",
+    "#config/tsconfig/*": "./config/tsconfig/*",
+    "#config/vitest/*.js": "./config/vitest/*.js",
+    "#config/vitest/*": "./config/vitest/*.js",
+    "#config/stryker/*.js": "./config/stryker/*.js",
+    "#config/stryker/*": "./config/stryker/*.js",
+    "#config/oxlint/*.js": "./config/oxlint/*.js",
+    "#config/oxlint/*": "./config/oxlint/*.js",
+    "#config/workers-test/*.js": "./config/workers-test/*.js",
+    "#config/workers-test/*": "./config/workers-test/*.js",
+    "#config/docs-lint/*.js": "./config/docs-lint/*.js",
+    "#config/docs-lint/*": "./config/docs-lint/*.js",
+    "#config/launch/*.js": "./config/launch/*.js",
+    "#config/launch/*": "./config/launch/*.js",
+    "#config/test-preset/*.js": "./config/test-preset/*.js",
+    "#config/test-preset/*": "./config/test-preset/*.js",
+    "#config/e2e-preset/*.js": "./config/e2e-preset/*.js",
+    "#config/e2e-preset/*": "./config/e2e-preset/*.js",
+    "#hooks/*.js": "./hooks/*.js",
+    "#hooks/*": "./hooks/*.js",
+    "#ci/*.js": "./ci/*.js",
+    "#ci/*": "./ci/*.js",
+    "#secret-gate/*.js": "./secret-gate/*.js",
+    "#secret-gate/*": "./secret-gate/*.js",
+    "#mcp/*.js": "./mcp/*.js",
+    "#mcp/*": "./mcp/*.js",
+    "#content/*.js": "./content/*.js",
+    "#content/*": "./content/*.js",
+    "#output-transforms/*.js": "./output-transforms/*.js",
+    "#output-transforms/*": "./output-transforms/*.js",
+    "#lint/*.js": "./lint/*.js",
+    "#lint/*": "./lint/*.js",
+    "#format/*.js": "./format/*.js",
+    "#format/*": "./format/*.js",
+    "#symlinker/*.js": "./symlinker/*.js",
+    "#symlinker/*": "./symlinker/*.js",
+    "#compiler/*.js": "./compiler/*.js",
+    "#compiler/*": "./compiler/*.js",
+    "#telemetry/*.js": "./telemetry/*.js",
+    "#telemetry/*": "./telemetry/*.js",
+    "#codex/app-server/client": "./codex/app-server/client.js",
+    "#codex/app-server/client.js": "./codex/app-server/client.js",
+    "#codex/app-server/types": "./codex/app-server/types.js",
+    "#codex/app-server/types.js": "./codex/app-server/types.js",
+    "#quality-engine": "./quality-engine/index.js",
+    "#quality-engine/*.js": "./quality-engine/*.js",
+    "#quality-engine/*": "./quality-engine/*.js",
+    "#ai-memory/checkpoint/*.js": "./ai-memory/checkpoint/*.js",
+    "#ai-memory/checkpoint/*": "./ai-memory/checkpoint/*.js",
+    "#ai-memory/facts/*.js": "./ai-memory/facts/*.js",
+    "#ai-memory/facts/*": "./ai-memory/facts/*.js",
+    "#ai-memory/hierarchy/*.js": "./ai-memory/hierarchy/*.js",
+    "#ai-memory/hierarchy/*": "./ai-memory/hierarchy/*.js",
+    "#runners": "./runners/index.js",
+    "#runners/*.js": "./runners/*.js",
+    "#runners/*": "./runners/*.js",
+    "#sync/*.js": "./blueprint/sync/*.js",
+    "#utils/*.js": "./blueprint/utils/*.js",
+    "#cross-repo/*.js": "./blueprint/cross-repo/*.js",
+    "#blueprint/sync/types.js": "./blueprint/sync/types.js",
+    "#blueprint/sync/auth.js": "./blueprint/sync/auth.js",
+    "#blueprint/sync/client.js": "./blueprint/sync/client.js",
+    "#projects.js": "./blueprint/projects.js",
+    "#next-action.js": "./blueprint/next-action.js",
+    "#types/execution-backend": "./blueprint/types/execution-backend.js",
+    "#types/execution-backend.js": "./blueprint/types/execution-backend.js",
+    "#*.js": "./blueprint/*.js",
+    "#*": "./blueprint/*.js"
+  }
+}

package/dist/esm/paths/state-root.d.ts

@@ -0,0 +1,23 @@
+export type LockScope = 'repo' | 'worktree' | 'user';
+export declare class NotInGitRepoError extends Error {
+    readonly cwd: string;
+    constructor(cwd: string, cause?: unknown);
+}
+export declare function getStateRoot(): string;
+export declare function getRepoKey(): string;
+export declare function getWorktreeKey(): string;
+/**
+ * Resolve the on-disk path for a named state surface.
+ *
+ * @param cwd  Optional project directory. When provided, git context is
+ *             derived from that directory instead of process.cwd()/
+ *             CLAUDE_PROJECT_DIR. Callers that receive a `cwd` parameter
+ *             (e.g. coldStartIfNeeded, auditMemoryRotation) should forward
+ *             it here so each project's state lands under its own key.
+ *             If `cwd` is not a git repo, NotInGitRepoError is thrown and
+ *             the caller falls back to the cwd-relative legacy path.
+ */
+export declare function getSurfacePath(name: string, scope: LockScope, cwd?: string): string;
+export declare function withLock<T>(scope: LockScope, fn: () => Promise<T> | T): Promise<T>;
+export declare function _clearCacheForTests(): void;
+//# sourceMappingURL=state-root.d.ts.map

package/dist/esm/paths/state-root.js

@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import envPaths from 'env-paths';
+import lockfile from 'proper-lockfile';
+export class NotInGitRepoError extends Error {
+    cwd;
+    constructor(cwd, cause) {
+        super(`Not inside a git repository (cwd=${cwd})`);
+        this.name = 'NotInGitRepoError';
+        this.cwd = cwd;
+        if (cause !== undefined) {
+            ;
+            this.cause = cause;
+        }
+    }
+}
+let cachedStateRoot = null;
+let cachedRepoKey = null;
+let cachedWorktreeKey = null;
+function resolveCwd() {
+    return process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+}
+function runGit(args, cwd) {
+    try {
+        const out = execFileSync('git', [...args], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return out.trim();
+    }
+    catch (error) {
+        throw new NotInGitRepoError(cwd, error);
+    }
+}
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+export function getStateRoot() {
+    if (cachedStateRoot !== null)
+        return cachedStateRoot;
+    const paths = envPaths('webpresso', { suffix: '' });
+    const root = paths.data;
+    cachedStateRoot = root;
+    return root;
+}
+export function getRepoKey() {
+    if (cachedRepoKey !== null)
+        return cachedRepoKey;
+    const cwd = resolveCwd();
+    const commonDir = runGit(['rev-parse', '--git-common-dir'], cwd);
+    const absolute = realpathSync(commonDir.startsWith('/') ? commonDir : join(cwd, commonDir));
+    cachedRepoKey = sha256Hex(absolute).slice(0, 16);
+    return cachedRepoKey;
+}
+export function getWorktreeKey() {
+    if (cachedWorktreeKey !== null)
+        return cachedWorktreeKey;
+    const cwd = resolveCwd();
+    const topLevel = runGit(['rev-parse', '--show-toplevel'], cwd);
+    const absolute = realpathSync(topLevel);
+    cachedWorktreeKey = sha256Hex(absolute).slice(0, 8);
+    return cachedWorktreeKey;
+}
+function computeRepoKey(cwd) {
+    const commonDir = runGit(['rev-parse', '--git-common-dir'], cwd);
+    const absolute = realpathSync(commonDir.startsWith('/') ? commonDir : join(cwd, commonDir));
+    return sha256Hex(absolute).slice(0, 16);
+}
+function computeWorktreeKey(cwd) {
+    const topLevel = runGit(['rev-parse', '--show-toplevel'], cwd);
+    const absolute = realpathSync(topLevel);
+    return sha256Hex(absolute).slice(0, 8);
+}
+/**
+ * Resolve the on-disk path for a named state surface.
+ *
+ * @param cwd  Optional project directory. When provided, git context is
+ *             derived from that directory instead of process.cwd()/
+ *             CLAUDE_PROJECT_DIR. Callers that receive a `cwd` parameter
+ *             (e.g. coldStartIfNeeded, auditMemoryRotation) should forward
+ *             it here so each project's state lands under its own key.
+ *             If `cwd` is not a git repo, NotInGitRepoError is thrown and
+ *             the caller falls back to the cwd-relative legacy path.
+ */
+export function getSurfacePath(name, scope, cwd) {
+    const root = getStateRoot();
+    if (scope === 'user') {
+        return join(root, name);
+    }
+    const repoKey = cwd !== undefined ? computeRepoKey(cwd) : getRepoKey();
+    if (scope === 'worktree') {
+        const wtKey = cwd !== undefined ? computeWorktreeKey(cwd) : getWorktreeKey();
+        return join(root, repoKey, 'worktree', wtKey, name);
+    }
+    return join(root, repoKey, name);
+}
+export async function withLock(scope, fn) {
+    if (scope === 'user') {
+        throw new Error('withLock does not support user-global scope; use repo or worktree');
+    }
+    const lockTarget = getSurfacePath('.lock', scope);
+    const release = await lockfile.lock(lockTarget, {
+        realpath: false,
+        retries: { retries: 5, minTimeout: 50, maxTimeout: 500, factor: 2 },
+    });
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}
+export function _clearCacheForTests() {
+    cachedStateRoot = null;
+    cachedRepoKey = null;
+    cachedWorktreeKey = null;
+}
+//# sourceMappingURL=state-root.js.map