devcontour-harness 0.1.0-alpha.5 → 0.1.0-alpha.7

package/lib/integrations/connector/summary.js

@@ -0,0 +1,59 @@
+import { redactor } from "../../environment/redaction.js";
+/** Абсолютные пути (POSIX и Windows) заменяются — они не ссылки для другого компьютера. */
+const PATHS = /(?<![\w.:/\\])(?:[A-Za-z]:\\|\/)(?:[\w.@+-]+[\\/])+[\w.@+-]*/g;
+export const stripPaths = (text) => text.replace(PATHS, '[локальный путь]');
+const shortSha = (sha) => (sha ? sha.slice(0, 12) : '—');
+export function summaryText(input) {
+    const r = input.result;
+    const redact = input.redact ?? redactor([]);
+    const gates = [...new Map(r.evidence.map((e) => [`${e.gate}/${e.phase}`, e])).values()]
+        .filter((e) => e.kind !== 'review')
+        .map((e) => {
+        const tests = e.tests
+            ? ` (${e.tests.filter((t) => t.status === 'passed').length}/${e.tests.length} тестов)`
+            : '';
+        return `- ${e.gate} [${e.phase}]: ${e.passed ? 'passed' : 'failed'}${tests} @ ${shortSha(e.sha)}`;
+    });
+    const reviews = r.evidence.filter((e) => e.kind === 'review');
+    const lines = [
+        input.marker,
+        input.historical
+            ? `**devcontour-harness: исторический результат** — относится к прежней постановке (снимок ${input.snapshot.revision.slice(0, 12)}), **не подтверждает текущие критерии и не закрывает задачу**.`
+            : `**devcontour-harness: ${r.outcome}** — ${input.task.key}`,
+        '',
+        `- Попытка: ${r.runId} (№ ${r.attempt}), репозиторий ${r.repositoryId}, target ${r.targetRef}`,
+        r.outcome === 'accepted'
+            ? `- SHA: base ${shortSha(r.shas.base)}, candidate ${r.shas.candidate}, integration/result ${r.shas.result}`
+            : `- SHA: candidate ${shortSha(r.shas.candidate)}, integration ${shortSha(r.shas.integration)}`,
+        ...(r.outcome !== 'accepted'
+            ? [`- Причина: ${r.stopReason.code}: ${r.stopReason.message.slice(0, 500)}`]
+            : []),
+        `- Снимок постановки: ${input.task.identity} @ ${input.snapshot.revision} (CAS ${input.snapshot.casRevision})`,
+        '',
+        '**Gates**',
+        ...(gates.length ? gates : ['- нет записей']),
+        ...(reviews.length
+            ? [
+                `- независимое ревью: ${reviews.map((e) => `${e.phase} ${e.passed ? 'approved' : 'rejected'}`).join(', ')}`,
+            ]
+            : []),
+        '',
+        '**Критерии**',
+        ...(input.criteria.length
+            ? input.criteria.map((c) => `- ${c.title}: ${c.outcome}` +
+                (c.gate ? ` ← ${c.gate}${c.testId ? '/' + c.testId : ''}` : '') +
+                (c.reason ? ` (${c.reason})` : ''))
+            : ['- нет критериев']),
+        '',
+        `Завершение: ${input.completion}`,
+        ...(r.limitations.length
+            ? ['', '**Ограничения**', ...r.limitations.slice(0, 10).map((l) => '- ' + l)]
+            : []),
+    ];
+    const body = stripPaths(redact(lines.join('\n'))).slice(0, 8000);
+    const title = stripPaths(redact(input.historical
+        ? `devcontour-harness: исторический результат ${input.task.key}`
+        : `devcontour-harness: ${r.outcome} ${input.task.key}`)).slice(0, 200);
+    // Маркер не маскируется и не обрезается: по нему выполняется read-back.
+    return { title, body: body.startsWith(input.marker) ? body : input.marker + '\n' + body };
+}

package/lib/integrations/connector/testing-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/integrations/connector/testing-worker.js

@@ -0,0 +1,81 @@
+/**
+ * Отдельный процесс набора проверки коннектора (fixture, не рабочий путь):
+ * доставка, reconcile или начало истории попытки над тем же каталогом
+ * состояния, с точками отказа. Crash — `process.exit(75)` в заданной точке.
+ * Итог — одна строка JSON в stdout.
+ *
+ * Запуск: `node --import tsx testing-worker.ts <spec.json>`.
+ */
+import { readFileSync } from 'node:fs';
+import { executionPolicySchema } from "../../contracts/index.js";
+import { Harness } from "../../control/harness.js";
+import { parseConfig } from "./config.js";
+import { Connector, openConnector } from "./commands.js";
+import { FakeRelayTransport, FileBarrier, faultyTransport, fileBackend, } from "./fake.js";
+import { createTransportFor } from "./registry.js";
+import { forbiddenAdapters } from "./testing.js";
+const spec = JSON.parse(readFileSync(process.argv[2], 'utf8'));
+const print = (value) => process.stdout.write(JSON.stringify(value) + '\n');
+try {
+    const loaded = parseConfig(spec.config, spec.baseDir);
+    const inner = spec.transport.kind === 'fake'
+        ? new FakeRelayTransport(fileBackend(spec.transport.file), {
+            provider: spec.transport.provider,
+            actor: spec.transport.actor,
+        })
+        : await createTransportFor(loaded);
+    const rules = (spec.faults ?? []).map(({ barrier, ...f }) => ({
+        ...f,
+        ...(barrier ? { barrier: new FileBarrier(barrier.dir, barrier.name, 60_000) } : {}),
+    }));
+    const writes = {};
+    const connector = await openConnector(loaded, {
+        stateDir: spec.state,
+        transport: faultyTransport(inner, rules),
+        ...(spec.owner ? { owner: spec.owner } : {}),
+        onStoreWrite: (what) => {
+            writes[what] = (writes[what] ?? 0) + 1;
+            if (spec.crashOnStoreWrite?.what === what && writes[what] === spec.crashOnStoreWrite.nth)
+                process.exit(75);
+        },
+    });
+    if (spec.action === 'begin-attempt') {
+        const a = spec.attempt;
+        await connector.history.beginAttempt(a.work, a.attempt, a.baseSha);
+        print({ ok: true });
+    }
+    else {
+        const h = Harness.open({
+            stateDir: spec.state,
+            policy: executionPolicySchema.parse(spec.policy),
+            baseDir: spec.repo,
+            adapters: forbiddenAdapters(spec.forbidden),
+            hooks: connector.hooks(),
+            resourceDatabase: spec.resources,
+        });
+        try {
+            if (spec.action === 'deliver') {
+                const envelope = await h.deliver(spec.workId, connector.sink);
+                print({ ok: true, result: envelope });
+            }
+            else {
+                const result = await connector.reconcile(h, spec.operation, Connector.decision(spec.decision));
+                print({ ok: true, result });
+            }
+        }
+        finally {
+            h.close();
+        }
+    }
+    connector.close();
+}
+catch (error) {
+    print({
+        ok: false,
+        error: {
+            code: error.code,
+            message: error instanceof Error ? error.message : String(error),
+        },
+    });
+    process.exitCode = 3;
+}

package/lib/integrations/connector/testing.d.ts

@@ -0,0 +1,205 @@
+import { type ExecutionPolicy, type RuntimeAdapter, type RuntimeName, type RuntimeRequest } from '../../contracts/index.ts';
+import { Harness } from '../../control/harness.ts';
+import { type ConnectorConfigInput, type CriterionMapping, type LoadedConfig } from './config.ts';
+import { Connector } from './commands.ts';
+import { type FaultRule } from './fake.ts';
+import type { ProviderId, RelayTransport, TaskColumn } from './transport.ts';
+export { FakeAdmin, FakeRelayTransport, FileBarrier, LocalBarrier, emptyFakeState, faultyTransport, fileBackend, memoryBackend, type Barrier, type FakeBackend, type FakeState, type FaultAction, type FaultRule, } from './fake.ts';
+/** Действия другого участника прямо в backend (постановка задач, правки, перехват). */
+export interface SuiteAdmin {
+    createTask(input: {
+        title: string;
+        description: string;
+        column?: TaskColumn;
+        criteria?: {
+            title: string;
+            summary?: string;
+        }[];
+        dependencies?: string[];
+        parentId?: string;
+    }): Promise<{
+        id: string;
+        key: string;
+        criteria: string[];
+    }>;
+    updateTask(id: string, patch: {
+        title?: string;
+        description?: string;
+    }): Promise<void>;
+    updateCriterion(id: string, criterionId: string, title: string): Promise<void>;
+    completeCriterion(id: string, criterionId: string, completed?: boolean): Promise<void>;
+    addDocument(taskId: string, doc: {
+        name: string;
+        body: string;
+    }): Promise<{
+        id: string;
+    }>;
+    updateDocument(id: string, body: string): Promise<void>;
+    addDependency(id: string, dependsOn: string): Promise<void>;
+    /** Перемещение с done guards backend (как у человека). */
+    move(id: string, column: TaskColumn): Promise<void>;
+    /** Комментарий другого участника (может содержать любой текст, включая маркер). */
+    comment(id: string, body: string): Promise<void>;
+    /** Перехват открытой сессии истории другим владельцем. */
+    takeover(sessionId: string): Promise<void>;
+}
+/** Как воссоздать транспорт в другом процессе (`testing-worker.ts`). */
+export type WorkerTransport = 
+/** Подделка над общим файлом состояния. */
+{
+    kind: 'fake';
+    file: string;
+    provider: ProviderId;
+    actor: string;
+}
+/** Настоящий адаптер по конфигурации коннектора (`createTransportFor`). */
+ | {
+    kind: 'config';
+};
+export interface SuiteProject {
+    provider: ProviderId;
+    projectId: string;
+    actor: string;
+    /** Поле `relay` конфигурации коннектора (без projectId/actor). */
+    relay: Record<string, unknown>;
+    /** Новый экземпляр транспорта этого проекта. */
+    transport(): RelayTransport;
+    worker: WorkerTransport;
+    admin: SuiteAdmin;
+    cleanup(): Promise<void>;
+}
+/** Backend набора: каждый вызов `project()` — новый изолированный проект. */
+export interface SuiteBackend {
+    name: string;
+    project(): Promise<SuiteProject>;
+}
+/** Backend набора на подделке; состояние каждого проекта — в своём файле SQLite. */
+export declare function fakeSuiteBackend(provider?: ProviderId): SuiteBackend;
+export declare const fixtureGreet = "exports.greet = (name) => 'Hello, ' + name + '!';\n";
+export interface RuntimeCalls {
+    writer: number;
+    reviewer: number;
+    plan: number;
+}
+export interface FixtureBehaviour {
+    writer?: 'implement' | 'incomplete';
+    reviewer?: 'approve' | 'reject';
+    /** Вызывается при каждом вызове writer до ответа (проверка порядка, отмена). */
+    onWriter?: (request: RuntimeRequest) => void | Promise<void>;
+}
+/** Runtime fixture в процессе: writer пишет greet, reviewer одобряет или отклоняет. */
+export declare function fixtureAdapters(calls: RuntimeCalls, behaviour?: FixtureBehaviour): Partial<Record<RuntimeName, RuntimeAdapter>>;
+/** Runtime, который не должен вызываться (доставка, reconcile): вызов — отказ и запись. */
+export declare function forbiddenAdapters(file: string): Partial<Record<RuntimeName, RuntimeAdapter>>;
+export declare function suitePolicy(repo: string, patch?: Partial<Record<string, unknown>>): ExecutionPolicy;
+export interface ScenarioOptions extends FixtureBehaviour {
+    criteria?: {
+        title: string;
+    }[];
+    mapping?: (Partial<CriterionMapping> & {
+        gate: string;
+    })[];
+    config?: (config: ConnectorConfigInput & Record<string, unknown>) => void;
+    maxAttempts?: number;
+    approvalMode?: 'agent' | 'operator';
+    description?: string;
+}
+export interface Opened {
+    connector: Connector;
+    h: Harness;
+    transport: RelayTransport & {
+        calls: Record<string, number>;
+    };
+    close(): void;
+}
+export interface WorkerSpec {
+    action: 'deliver' | 'reconcile' | 'begin-attempt';
+    workId?: string;
+    operation?: string;
+    decision?: string;
+    faults?: (Omit<FaultRule, 'barrier' | 'after'> & {
+        barrier?: {
+            dir: string;
+            name: string;
+        };
+    })[];
+    crashOnStoreWrite?: {
+        what: string;
+        nth: number;
+    };
+    owner?: string;
+    attempt?: {
+        work: unknown;
+        attempt: unknown;
+        baseSha: string;
+    };
+}
+export interface WorkerResult {
+    code: number | null;
+    output?: {
+        ok: boolean;
+        result?: unknown;
+        error?: {
+            code?: string;
+            message: string;
+        };
+    };
+    stderr: string;
+}
+export interface Scenario {
+    project: SuiteProject;
+    task: {
+        id: string;
+        key: string;
+        criteria: string[];
+    };
+    root: string;
+    repo: string;
+    state: string;
+    policy: ExecutionPolicy;
+    calls: RuntimeCalls;
+    config: ConnectorConfigInput & Record<string, unknown>;
+    loaded(): LoadedConfig;
+    workId: string;
+    open(o?: {
+        faults?: FaultRule[];
+        onStoreWrite?: (what: string) => void;
+        transport?: RelayTransport;
+        behaviour?: FixtureBehaviour;
+        secrets?: string[];
+    }): Promise<Opened>;
+    /** Снимок и `run --source` (ревью плана, исполнение, доставка). */
+    snapshotAndRun(o?: Parameters<Scenario['open']>[0]): Promise<{
+        opened: Opened;
+        run: Awaited<ReturnType<Connector['run']>>;
+    }>;
+    /** Снимок и исполнение без доставки (результат принят локально). */
+    runOnly(o?: Parameters<Scenario['open']>[0]): Promise<Opened>;
+    target(): string;
+    worker(spec: WorkerSpec, timeoutMs?: number): Promise<WorkerResult>;
+    /** Дождаться истечения lease упавшего владельца (перехват — только после срока). */
+    waitLeases(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare function scenario(backend: SuiteBackend, o?: ScenarioOptions): Promise<Scenario>;
+/** Комментарии harness у задачи (по маркеру) — счёт у получателя, не локальных вызовов. */
+export declare function harnessComments(t: RelayTransport, taskId: string): Promise<import("./transport.ts").CommentRecord[]>;
+export declare function markerCount(t: RelayTransport, taskId: string, marker: string): Promise<number>;
+/** Все чекпоинты сессий истории поручения у получателя. */
+export declare function historyCheckpoints(opened: Opened, workId: string): Promise<{
+    session: string;
+    kind: string;
+    title: string;
+    body: string;
+}[]>;
+export interface SuiteOptions {
+    /** Предел одного теста, мс. */
+    timeoutMs?: number;
+    /** Выполнить только тесты с этими ID (`W02`, `D03`…). */
+    only?: string[];
+}
+/**
+ * Общий контрактный набор коннектора для backend. Имена тестов содержат ID
+ * условий приёмки и имя backend.
+ */
+export declare function connectorSuite(backend: SuiteBackend, options?: SuiteOptions): void;