@haystackeditor/cli 0.15.29 → 0.15.31

package/dist/commands/verify-history.js

@@ -0,0 +1,152 @@
+import { resolveAuthContext } from '../utils/auth.js';
+import { haystackJson, HaystackApiError } from '../utils/haystack-api.js';
+const HEALTH = ['healthy', 'degraded', 'infrastructure-error', 'not-executed', 'unknown'];
+const LIFECYCLES = ['complete', 'failed', 'cancelled', 'budget-stopped', 'account-action'];
+const RUN_ID = /^cv_[0-9a-f]{48}$/;
+const COMMIT = /^[0-9a-f]{40}$/;
+const REPO_COMPONENT = /^(?!\.{1,2}$)[A-Za-z0-9_.-]{1,100}$/;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function count(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function timestamp(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+}
+/** Reject contradictory or mismatched data before printing health or findings. */
+export function parseVerifyHistoryReport(value, expected) {
+    const invalid = () => {
+        throw new Error('The hosted verifier returned invalid or mismatched history. No reliability summary was accepted.');
+    };
+    if (!record(value) || value.version !== 'dv-verify-history-v1'
+        || value.provider !== 'haystack' || value.scope !== 'user'
+        || !record(value.repository)
+        || typeof value.repository.owner !== 'string' || typeof value.repository.name !== 'string'
+        || value.repository.owner !== expected.owner
+        || value.repository.name !== expected.name
+        || typeof value.repository.repositoryId !== 'string'
+        || !/^github\.com:[1-9]\d*$/.test(value.repository.repositoryId)
+        || value.limit !== expected.limit || typeof value.hasMore !== 'boolean'
+        || !Array.isArray(value.runs) || value.runs.length > expected.limit
+        || (value.hasMore && value.runs.length !== expected.limit)
+        || !record(value.summary) || !record(value.summary.counts))
+        return invalid();
+    const counts = {
+        healthy: 0, degraded: 0, 'infrastructure-error': 0, 'not-executed': 0, unknown: 0,
+    };
+    const seen = new Set();
+    let usable = 0;
+    let previousCompletedAt = Infinity;
+    for (const run of value.runs) {
+        if (!record(run) || typeof run.runId !== 'string' || !RUN_ID.test(run.runId)
+            || seen.has(run.runId)
+            || typeof run.baseCommit !== 'string' || !COMMIT.test(run.baseCommit)
+            || typeof run.headCommit !== 'string' || !COMMIT.test(run.headCommit)
+            || !timestamp(run.createdAt) || !timestamp(run.completedAt)
+            || Date.parse(run.completedAt) < Date.parse(run.createdAt)
+            || Date.parse(run.completedAt) > previousCompletedAt
+            || (run.status !== 'complete' && run.status !== 'errored')
+            || (run.lifecycle !== null && !LIFECYCLES.includes(run.lifecycle))
+            || !HEALTH.includes(run.health)
+            || (run.regressionCount !== null && !count(run.regressionCount))
+            || (run.executedCaseCount !== null && !count(run.executedCaseCount))
+            || !Array.isArray(run.degradationCodes)
+            || run.degradationCodes.some(code => typeof code !== 'string' || code.length === 0)
+            || new Set(run.degradationCodes).size !== run.degradationCodes.length
+            || (run.supersededBy !== null && (typeof run.supersededBy !== 'string'
+                || !RUN_ID.test(run.supersededBy) || run.supersededBy === run.runId)))
+            return invalid();
+        if (run.health === 'unknown') {
+            if (run.status !== 'errored' || run.lifecycle !== null || run.regressionCount !== null
+                || run.executedCaseCount !== null || run.degradationCodes.length !== 0)
+                return invalid();
+        }
+        else if (run.lifecycle === null || run.regressionCount === null || run.executedCaseCount === null) {
+            return invalid();
+        }
+        else if ((run.lifecycle === 'complete') !== (run.status === 'complete')) {
+            return invalid();
+        }
+        if (run.health === 'healthy' && (run.lifecycle !== 'complete'
+            || run.executedCaseCount === 0 || run.degradationCodes.length !== 0))
+            return invalid();
+        if (run.health === 'not-executed' && (run.executedCaseCount !== 0 || run.regressionCount !== 0))
+            return invalid();
+        if (run.executedCaseCount === 0 && run.regressionCount !== null && run.regressionCount !== 0)
+            return invalid();
+        seen.add(run.runId);
+        previousCompletedAt = Date.parse(run.completedAt);
+        counts[run.health]++;
+        if ((run.health === 'healthy' || run.health === 'degraded')
+            && typeof run.executedCaseCount === 'number' && run.executedCaseCount > 0)
+            usable++;
+    }
+    const usableRate = value.runs.length === 0 ? null : usable / value.runs.length;
+    const summaryCounts = value.summary.counts;
+    if (value.summary.total !== value.runs.length || value.summary.usableRate !== usableRate
+        || HEALTH.some(health => summaryCounts[health] !== counts[health]))
+        return invalid();
+    return value;
+}
+function terminalSafe(value) {
+    return Array.from(value).filter(character => {
+        const point = character.codePointAt(0);
+        return point >= 32 && !(point >= 127 && point <= 159);
+    }).join('');
+}
+export function formatVerifyHistory(report) {
+    const { summary } = report;
+    const lines = [
+        `Your verification history for ${report.repository.owner}/${report.repository.name}`,
+        `Latest ${summary.total} finished runs for the selected account (limit ${report.limit}).`,
+    ];
+    if (summary.total === 0) {
+        lines.push('No finished hosted fleet runs found for this account and repository.');
+        return lines.join('\n');
+    }
+    const usable = report.runs.filter(run => (run.health === 'healthy' || run.health === 'degraded')
+        && run.executedCaseCount !== null && run.executedCaseCount > 0).length;
+    lines.push(`Usable evidence: ${Math.round(summary.usableRate * 100)}% of these runs (${usable}/${summary.total}).`, `Healthy: ${summary.counts.healthy}; partially degraded: ${summary.counts.degraded}; infrastructure error: ${summary.counts['infrastructure-error']}; not executed: ${summary.counts['not-executed']}; unknown: ${summary.counts.unknown}.`, 'Usable means healthy or partially degraded with at least one executed check.', 'This measures execution reliability. Bugs found are listed separately; they do not lower this rate.', '');
+    for (const run of report.runs) {
+        const health = run.health === 'degraded' ? 'partially degraded' : run.health;
+        const checks = run.executedCaseCount === null ? 'unknown checks executed' : `${run.executedCaseCount} checks executed`;
+        const regressions = run.regressionCount === null ? 'bugs found unknown'
+            : `${run.regressionCount} ${run.regressionCount === 1 ? 'bug' : 'bugs'} found`;
+        lines.push(`${terminalSafe(run.completedAt)}  ${health}  ${checks}  ${regressions}`, `  ${run.runId}  ${run.baseCommit.slice(0, 12)} -> ${run.headCommit.slice(0, 12)}`);
+        if (run.lifecycle && run.lifecycle !== 'complete')
+            lines.push(`  Run outcome: ${run.lifecycle}`);
+        if (run.degradationCodes.length)
+            lines.push(`  Limitations: ${run.degradationCodes.map(terminalSafe).join(', ')}`);
+        if (run.supersededBy)
+            lines.push(`  Replaced by: ${run.supersededBy}`);
+    }
+    if (report.hasMore)
+        lines.push('', 'Older finished runs exist. Increase --limit to show up to 100.');
+    return lines.join('\n');
+}
+export async function verifyHistoryCommand(repository, options) {
+    const parts = repository.split('/');
+    if (parts.length !== 2 || !parts.every(part => REPO_COMPONENT.test(part))) {
+        throw new Error('Use an exact GitHub owner/repository name for verification history.');
+    }
+    const limitText = options.limit ?? '20';
+    if (!/^[1-9]\d*$/.test(limitText) || Number(limitText) > 100) {
+        throw new Error('--limit must be a whole number from 1 to 100.');
+    }
+    const [owner, name] = parts;
+    const limit = Number(limitText);
+    const auth = await resolveAuthContext({ preferredLogin: options.account, owner, repo: name });
+    let response;
+    try {
+        response = await haystackJson(`/api/agent/cloud-verifier/history/${encodeURIComponent(owner)}/${encodeURIComponent(name)}?limit=${limit}`, auth.token, { method: 'GET' });
+    }
+    catch (error) {
+        if (error instanceof HaystackApiError && error.status === 404) {
+            throw new Error('Verification history was not found for this repository and account. Check repository access and use --account <login> if needed.');
+        }
+        throw error;
+    }
+    const report = parseVerifyHistoryReport(response, { owner, name, limit });
+    process.stdout.write((options.json ? JSON.stringify(report, null, 2) : formatVerifyHistory(report)) + '\n');
+}

package/dist/commands/verify-hosted.d.ts

@@ -1,12 +1,14 @@
+declare const FLEET_PROJECTION_VERSION = "dv-cloud-verifier-fleet-runner-projection-v1";
 export interface HostedIntent {
     problem: string;
     goal: string;
     intended_outcomes: string[];
 }
 export interface HostedStartOptions {
+    provider?: 'haystack';
     base: string;
     head: string;
-    intentFile: string;
+    intentFile?: string;
     idempotencyKey?: string;
     replayPlanFrom?: string;
     account?: string;
@@ -44,6 +46,11 @@ export interface HostedRunState {
     completedAt?: string;
     output?: Record<string, unknown>;
     result?: HostedRunnerResult;
+    provider?: 'haystack';
+    version?: typeof FLEET_PROJECTION_VERSION;
+    /** Opaque P0 documents, authoritatively validated by the hosted service. */
+    progress?: Record<string, unknown>;
+    fleetResult?: Record<string, unknown>;
     error?: string;
 }
 export interface HostedPollOptions {
@@ -62,7 +69,10 @@ export declare function parseHostedRepository(value: string): {
     fullName: string;
 };
 export declare function readHostedIntentFile(intentFile: string | undefined): HostedIntent;
-export declare function defaultHostedIdempotencyKey(repository: string, baseCommit: string, headCommit: string, replayPlanFrom?: string): string;
+export declare function defaultHostedIdempotencyKey(repository: string, baseCommit: string, headCommit: string, replayPlanFrom?: string, fleetRequest?: {
+    provider: 'haystack';
+    intent?: HostedIntent;
+}): string;
 export declare function hostedPollingOptions(interval: string | undefined, timeout: string | undefined, onStatus?: (state: HostedRunState) => void): HostedPollOptions;
 export declare function startHostedVerification(repositoryArg: string, options: HostedStartOptions, token: string): Promise<{
     state: HostedRunState;