@kylecheng3146/agent-ops 0.0.1

package/dist/runtime/src/adapters/claude/events.js

@@ -0,0 +1,8 @@
+export const CLAUDE_SUPPORTED_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "Stop"
+];
+export function claudeNonInteractiveTrust(printMode) {
+    return printMode ? "dialog-skipped" : "interactive-dialog";
+}

package/dist/runtime/src/adapters/claude/input.js

@@ -0,0 +1,38 @@
+import { normalizeHookEvent } from "../../hooks/normalize.js";
+import { normalizeShellHookEvent } from "../../hooks/shell.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function claudeStopRecursionMarker(input) {
+    return (isRecord(input) &&
+        input.hook_event_name === "Stop" &&
+        input.stop_hook_active === true);
+}
+export function normalizeClaudeHookInput(input) {
+    if (!isRecord(input)) {
+        return normalizeHookEvent(input);
+    }
+    const projectRoot = input.cwd;
+    if (input.hook_event_name === "SessionStart") {
+        return normalizeHookEvent({
+            event: "session-start",
+            projectRoot
+        });
+    }
+    if (input.hook_event_name === "Stop") {
+        return normalizeHookEvent({
+            event: "stop",
+            projectRoot
+        });
+    }
+    if (input.hook_event_name === "PreToolUse" &&
+        input.tool_name === "Bash" &&
+        isRecord(input.tool_input) &&
+        typeof input.tool_input.command === "string") {
+        return normalizeShellHookEvent(input.tool_input.command, projectRoot);
+    }
+    return normalizeHookEvent({
+        event: "unsupported",
+        projectRoot
+    });
+}

package/dist/runtime/src/adapters/claude/output.js

@@ -0,0 +1,30 @@
+function json(value) {
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify(value),
+        stderr: ""
+    };
+}
+export function claudeHookOutput(event, result) {
+    if (result.action === "continue" && result.status === "PASS") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    if (event === "PreToolUse" && result.action === "block") {
+        return json({
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: result.code
+            }
+        });
+    }
+    if (event === "Stop" && result.action === "block") {
+        return json({
+            decision: "block",
+            reason: result.code
+        });
+    }
+    return json({
+        systemMessage: `agent-ops: ${result.code}`
+    });
+}

package/dist/runtime/src/adapters/codex/config.js

@@ -0,0 +1,93 @@
+import { AgentOpsError } from "../../fs/paths.js";
+const COMMAND_PREFIX = "agent-ops hook codex ";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function commandHook(event) {
+    const command = `${COMMAND_PREFIX}${event}`;
+    return {
+        type: "command",
+        command,
+        commandWindows: command,
+        timeout: 30,
+        statusMessage: `Running agent-ops ${event}`
+    };
+}
+function matcherGroup(event) {
+    return {
+        ...(event === "PreToolUse" ? { matcher: "^Bash$" } : {}),
+        hooks: [commandHook(event)]
+    };
+}
+export function codexHookTarget(scope) {
+    return {
+        path: ".codex/hooks.json",
+        representation: "json",
+        requiresProjectTrust: scope === "project"
+    };
+}
+export function buildCodexHookConfig(capabilities) {
+    const hooks = {};
+    if (capabilities.includes("lifecycle-summary")) {
+        hooks.SessionStart = [matcherGroup("SessionStart")];
+    }
+    if (capabilities.includes("command-policy")) {
+        hooks.PreToolUse = [matcherGroup("PreToolUse")];
+    }
+    if (capabilities.includes("optional-stop-verify")) {
+        hooks.Stop = [matcherGroup("Stop")];
+    }
+    return {
+        description: "Portable agent-ops lifecycle hooks.",
+        hooks
+    };
+}
+function isOwnedHandler(hook) {
+    return (isRecord(hook) &&
+        typeof hook.command === "string" &&
+        hook.command.startsWith(COMMAND_PREFIX));
+}
+function withoutOwnedHandlers(value) {
+    if (!isRecord(value) || !Array.isArray(value.hooks)) {
+        return value;
+    }
+    const hooks = value.hooks.filter((hook) => !isOwnedHandler(hook));
+    return hooks.length === 0 ? null : { ...value, hooks };
+}
+function hookRecord(value) {
+    if (!isRecord(value)) {
+        throw new AgentOpsError("CODEX_HOOK_CONFIG_INVALID", "Codex hook configuration must be a JSON object.");
+    }
+    if (value.hooks === undefined) {
+        return {};
+    }
+    if (!isRecord(value.hooks) ||
+        Object.values(value.hooks).some((groups) => !Array.isArray(groups))) {
+        throw new AgentOpsError("CODEX_HOOK_CONFIG_INVALID", "Codex hook groups must be arrays.");
+    }
+    return value.hooks;
+}
+export function mergeCodexHookConfig(existing, managed) {
+    if (!isRecord(existing)) {
+        throw new AgentOpsError("CODEX_HOOK_CONFIG_INVALID", "Codex hook configuration must be a JSON object.");
+    }
+    const existingHooks = hookRecord(existing);
+    const hooks = {};
+    const eventNames = new Set([
+        ...Object.keys(existingHooks),
+        ...Object.keys(managed.hooks)
+    ]);
+    for (const eventName of eventNames) {
+        const preserved = (existingHooks[eventName] ?? [])
+            .map(withoutOwnedHandlers)
+            .filter((group) => group !== null);
+        const additions = managed.hooks[eventName] ?? [];
+        if (preserved.length > 0 || additions.length > 0) {
+            hooks[eventName] = [...preserved, ...additions];
+        }
+    }
+    return {
+        ...existing,
+        hooks
+    };
+}

package/dist/runtime/src/adapters/codex/events.js

@@ -0,0 +1,8 @@
+export const CODEX_SUPPORTED_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "Stop"
+];
+export function codexMatcherSupport(event) {
+    return event === "PreToolUse" ? "tool-name" : "unsupported";
+}

package/dist/runtime/src/adapters/codex/input.js

@@ -0,0 +1,41 @@
+import { normalizeHookEvent } from "../../hooks/normalize.js";
+import { normalizeShellHookEvent } from "../../hooks/shell.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shellCommand(input) {
+    if (!isRecord(input.tool_input)) {
+        return null;
+    }
+    const candidate = input.tool_input.command ?? input.tool_input.cmd;
+    return typeof candidate === "string" ? candidate : null;
+}
+export function normalizeCodexHookInput(input) {
+    if (!isRecord(input)) {
+        return normalizeHookEvent(input);
+    }
+    const projectRoot = input.cwd;
+    if (input.hook_event_name === "SessionStart") {
+        return normalizeHookEvent({
+            event: "session-start",
+            projectRoot
+        });
+    }
+    if (input.hook_event_name === "Stop") {
+        return normalizeHookEvent({
+            event: "stop",
+            projectRoot
+        });
+    }
+    if (input.hook_event_name === "PreToolUse" &&
+        input.tool_name === "Bash") {
+        const rawCommand = shellCommand(input);
+        if (rawCommand !== null) {
+            return normalizeShellHookEvent(rawCommand, projectRoot);
+        }
+    }
+    return normalizeHookEvent({
+        event: "unsupported",
+        projectRoot
+    });
+}

package/dist/runtime/src/adapters/codex/output.js

@@ -0,0 +1,24 @@
+export const CODEX_NON_ZERO_EXIT_BEHAVIOR = "UNKNOWN";
+export const CODEX_PRE_TOOL_BLOCKING = "UNKNOWN";
+export function codexHookOutput(event, result) {
+    if (result.action === "continue" && result.status === "PASS") {
+        return { exitCode: 0, stdout: "" };
+    }
+    if (event === "PreToolUse") {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                systemMessage: `agent-ops: ${result.code}`
+            })
+        };
+    }
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+            continue: result.action !== "block",
+            ...(result.action === "block"
+                ? { stopReason: result.code }
+                : { systemMessage: `agent-ops: ${result.code}` })
+        })
+    };
+}

package/dist/runtime/src/config/explain.js

@@ -0,0 +1,34 @@
+export function explainConfig(merged) {
+    return {
+        schemaVersion: merged.config.schemaVersion,
+        profiles: merged.provenance.profiles.map((entry) => ({
+            id: entry.value,
+            source: entry.source,
+            sourcePath: entry.sourcePath
+        })),
+        verificationCommands: merged.provenance.verificationCommands.map((entry) => ({
+            id: entry.value.id,
+            required: entry.value.required,
+            shell: entry.value.shell === true,
+            evidence: {
+                kind: entry.value.evidence.kind,
+                minimum: entry.value.evidence.minimum ?? null
+            },
+            source: entry.source,
+            sourcePath: entry.sourcePath
+        })),
+        pathMappings: merged.provenance.pathMappings.map((entry) => ({
+            path: entry.value.path,
+            verifierIds: [...entry.value.verifierIds],
+            source: entry.source,
+            sourcePath: entry.sourcePath
+        })),
+        securityExceptions: merged.provenance.securityExceptions.map((entry) => ({
+            ruleId: entry.value.ruleId,
+            scope: entry.value.scope,
+            expiresAt: entry.value.expiresAt,
+            source: entry.source,
+            sourcePath: entry.sourcePath
+        }))
+    };
+}

package/dist/runtime/src/config/load.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import { AgentOpsError } from "../fs/paths.js";
+import { previewConfigMigration } from "./migrate.js";
+export async function loadConfigFile(path) {
+    let source;
+    try {
+        source = await readFile(path, "utf8");
+    }
+    catch (error) {
+        throw new AgentOpsError("CONFIG_READ_FAILED", `Unable to read config: ${path}`, { cause: error });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new AgentOpsError("CONFIG_PARSE_FAILED", `Unable to parse config JSON: ${path}`, { cause: error });
+    }
+    const preview = previewConfigMigration(parsed);
+    return {
+        config: preview.migrated,
+        sourcePath: path,
+        migration: { steps: preview.steps }
+    };
+}

package/dist/runtime/src/config/merge.js

@@ -0,0 +1,170 @@
+import { AgentOpsError } from "../fs/paths.js";
+import { validateConfig } from "../schema/validate.js";
+const SOURCE_RANK = {
+    default: 0,
+    user: 1,
+    project: 2
+};
+function clone(value) {
+    return structuredClone(value);
+}
+function mappingKey(mapping) {
+    return mapping.path.toLowerCase();
+}
+function exceptionKey(exception) {
+    return `${exception.ruleId}\0${exception.scope.toLowerCase()}`;
+}
+function sameException(left, right) {
+    return (left.ruleId === right.ruleId &&
+        left.scope === right.scope &&
+        left.expiresAt === right.expiresAt &&
+        left.reason === right.reason);
+}
+function assertUniqueKeys(values, keyOf, layer, collection) {
+    const keys = new Set();
+    for (const value of values) {
+        const key = keyOf(value);
+        if (keys.has(key)) {
+            throw new AgentOpsError("CONFIG_DUPLICATE_ID", `Duplicate ${collection} stable ID in ${layer.source} config.`);
+        }
+        keys.add(key);
+    }
+}
+function assertLayer(layer) {
+    const validation = validateConfig(layer.config);
+    if (!validation.ok) {
+        const first = validation.errors[0];
+        throw new AgentOpsError(first?.code === "DUPLICATE_ID"
+            ? "CONFIG_DUPLICATE_ID"
+            : "CONFIG_INVALID", `Invalid ${layer.source} config${first === undefined ? "." : `: ${first.code} at ${first.path}.`}`);
+    }
+    assertUniqueKeys(layer.config.verification.commands, (command) => command.id, layer, "verification command");
+    assertUniqueKeys(layer.config.pathMappings, mappingKey, layer, "path mapping");
+    assertUniqueKeys(layer.config.securityExceptions, exceptionKey, layer, "security exception");
+}
+function assertProjectCommandIsMonotonic(existing, candidate) {
+    if (existing === undefined ||
+        existing.source === "project") {
+        return;
+    }
+    const previous = existing.value;
+    const previousMinimum = previous.evidence.minimum ?? 0;
+    const candidateMinimum = candidate.evidence.minimum ?? 0;
+    const weakensRequired = previous.required && !candidate.required;
+    const enablesShell = previous.shell !== true && candidate.shell === true;
+    const changesProtectedExecution = previous.required &&
+        (previous.command !== candidate.command ||
+            previous.cwd !== candidate.cwd ||
+            (previous.shell === true) !== (candidate.shell === true) ||
+            previous.args.length !== candidate.args.length ||
+            previous.args.some((argument, index) => argument !== candidate.args[index]));
+    const lowersEvidence = previous.required &&
+        (previous.evidence.kind !== candidate.evidence.kind ||
+            candidateMinimum < previousMinimum);
+    const weakensTimeout = previous.required &&
+        previous.timeoutMs !== undefined &&
+        (candidate.timeoutMs === undefined ||
+            candidate.timeoutMs > previous.timeoutMs);
+    if (weakensRequired ||
+        enablesShell ||
+        changesProtectedExecution ||
+        lowersEvidence ||
+        weakensTimeout) {
+        throw new AgentOpsError("PROJECT_GUARDRAIL_WEAKENING", `Project command cannot weaken protected verifier ID: ${candidate.id}`);
+    }
+}
+function assertProjectMappingIsMonotonic(existing, candidate) {
+    if (existing === undefined || existing.source === "project") {
+        return;
+    }
+    const candidateIds = new Set(candidate.verifierIds);
+    if (existing.value.path !== candidate.path ||
+        existing.value.verifierIds.some((verifierId) => !candidateIds.has(verifierId))) {
+        throw new AgentOpsError("PROJECT_GUARDRAIL_WEAKENING", `Project mapping cannot drop verifier coverage for: ${candidate.path}`);
+    }
+}
+function effective(value, layer) {
+    return {
+        value: clone(value),
+        source: layer.source,
+        sourcePath: layer.sourcePath
+    };
+}
+export function mergeConfigLayers(inputLayers) {
+    if (inputLayers.length === 0) {
+        throw new AgentOpsError("CONFIG_LAYER_REQUIRED", "At least one configuration layer is required.");
+    }
+    const sources = new Set();
+    for (const layer of inputLayers) {
+        if (sources.has(layer.source)) {
+            throw new AgentOpsError("CONFIG_LAYER_DUPLICATE", `Configuration source may appear only once: ${layer.source}`);
+        }
+        sources.add(layer.source);
+        assertLayer(layer);
+    }
+    const layers = [...inputLayers].sort((left, right) => SOURCE_RANK[left.source] - SOURCE_RANK[right.source]);
+    const profiles = new Map();
+    const commands = new Map();
+    const mappings = new Map();
+    const exceptions = new Map();
+    let schemaVersion;
+    for (const layer of layers) {
+        schemaVersion = effective(layer.config.schemaVersion, layer);
+        for (const profile of layer.config.profiles) {
+            profiles.set(profile, effective(profile, layer));
+        }
+        for (const command of layer.config.verification.commands) {
+            if (layer.source === "project") {
+                assertProjectCommandIsMonotonic(commands.get(command.id), command);
+            }
+            commands.set(command.id, effective(command, layer));
+        }
+        for (const mapping of layer.config.pathMappings) {
+            const key = mappingKey(mapping);
+            if (layer.source === "project") {
+                assertProjectMappingIsMonotonic(mappings.get(key), mapping);
+            }
+            mappings.set(key, effective(mapping, layer));
+        }
+        for (const securityException of layer.config.securityExceptions) {
+            const key = exceptionKey(securityException);
+            const existing = exceptions.get(key);
+            if (layer.source === "project") {
+                if (existing === undefined ||
+                    !sameException(existing.value, securityException)) {
+                    throw new AgentOpsError("PROJECT_SECURITY_WEAKENING", `Project config cannot authorize security exception: ${securityException.ruleId}`);
+                }
+                continue;
+            }
+            exceptions.set(key, effective(securityException, layer));
+        }
+    }
+    if (schemaVersion === undefined) {
+        throw new AgentOpsError("CONFIG_LAYER_REQUIRED", "At least one configuration layer is required.");
+    }
+    const provenance = {
+        schemaVersion,
+        profiles: [...profiles.values()],
+        verificationCommands: [...commands.values()],
+        pathMappings: [...mappings.values()],
+        securityExceptions: [...exceptions.values()]
+    };
+    const config = {
+        schemaVersion: 1,
+        profiles: provenance.profiles.map(({ value }) => value),
+        verification: {
+            commands: provenance.verificationCommands.map(({ value }) => value)
+        },
+        pathMappings: provenance.pathMappings.map(({ value }) => value),
+        securityExceptions: provenance.securityExceptions.map(({ value }) => value)
+    };
+    const validation = validateConfig(config);
+    if (!validation.ok) {
+        const first = validation.errors[0];
+        throw new AgentOpsError("CONFIG_MERGE_INVALID", `Merged config is invalid${first === undefined ? "." : `: ${first.code} at ${first.path}.`}`);
+    }
+    return {
+        config: clone(validation.value),
+        provenance: clone(provenance)
+    };
+}

package/dist/runtime/src/config/migrate.js

@@ -0,0 +1,61 @@
+import { SCHEMA_VERSION } from "../contracts.js";
+import { AgentOpsError } from "../fs/paths.js";
+import { validateConfig } from "../schema/validate.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clone(value) {
+    return structuredClone(value);
+}
+const MIGRATIONS = new Map([
+    [
+        0,
+        (input) => {
+            const { commands, schemaVersion: _schemaVersion, ...rest } = input;
+            return {
+                ...rest,
+                schemaVersion: 1,
+                verification: { commands: clone(commands) }
+            };
+        }
+    ]
+]);
+function schemaVersionOf(value) {
+    if (!isRecord(value) ||
+        !Number.isSafeInteger(value.schemaVersion) ||
+        value.schemaVersion < 0) {
+        throw new AgentOpsError("CONFIG_SCHEMA_INVALID", "Config schemaVersion must be a non-negative integer.");
+    }
+    return value.schemaVersion;
+}
+export function previewConfigMigration(input) {
+    const sourceVersion = schemaVersionOf(input);
+    if (sourceVersion > SCHEMA_VERSION) {
+        throw new AgentOpsError("CONFIG_SCHEMA_FUTURE", `Config schemaVersion ${sourceVersion} is newer than supported version ${SCHEMA_VERSION}.`);
+    }
+    let migrated = clone(input);
+    let version = sourceVersion;
+    const steps = [];
+    while (version < SCHEMA_VERSION) {
+        const migration = MIGRATIONS.get(version);
+        if (migration === undefined || !isRecord(migrated)) {
+            throw new AgentOpsError("CONFIG_MIGRATION_MISSING", `No migration is registered from config schemaVersion ${version}.`);
+        }
+        const nextVersion = version + 1;
+        migrated = migration(clone(migrated));
+        if (schemaVersionOf(migrated) !== nextVersion) {
+            throw new AgentOpsError("CONFIG_MIGRATION_INVALID", `Migration ${version} must produce schemaVersion ${nextVersion}.`);
+        }
+        steps.push({ fromVersion: version, toVersion: nextVersion });
+        version = nextVersion;
+    }
+    const validation = validateConfig(migrated);
+    if (!validation.ok) {
+        const first = validation.errors[0];
+        throw new AgentOpsError("CONFIG_INVALID", `Migrated config is invalid${first === undefined ? "." : `: ${first.code} at ${first.path}.`}`);
+    }
+    return {
+        migrated: clone(validation.value),
+        steps
+    };
+}

package/dist/runtime/src/contracts.js

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = 1;

package/dist/runtime/src/discovery/go.js

@@ -0,0 +1,145 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+const MAX_GO_MOD_BYTES = 1024 * 1024;
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+async function readGoMod(filePath) {
+    let status;
+    try {
+        status = await lstat(filePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return { kind: "missing" };
+        }
+        return {
+            kind: "invalid",
+            message: "go.mod could not be inspected safely."
+        };
+    }
+    if (status.isSymbolicLink() || !status.isFile()) {
+        return {
+            kind: "invalid",
+            message: "go.mod must be a regular file."
+        };
+    }
+    if (status.size > MAX_GO_MOD_BYTES) {
+        return {
+            kind: "invalid",
+            message: "go.mod exceeds the discovery size limit."
+        };
+    }
+    let handle;
+    try {
+        handle = await open(filePath, constants.O_RDONLY |
+            constants.O_NOFOLLOW |
+            constants.O_NONBLOCK);
+        const openedStatus = await handle.stat();
+        if (!openedStatus.isFile()) {
+            return {
+                kind: "invalid",
+                message: "go.mod must remain a regular file."
+            };
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        while (totalBytes <= MAX_GO_MOD_BYTES) {
+            const remaining = MAX_GO_MOD_BYTES + 1 - totalBytes;
+            const buffer = Buffer.alloc(Math.min(64 * 1024, remaining));
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0) {
+                return {
+                    kind: "source",
+                    source: Buffer.concat(chunks, totalBytes).toString("utf8")
+                };
+            }
+            chunks.push(buffer.subarray(0, bytesRead));
+            totalBytes += bytesRead;
+        }
+        return {
+            kind: "invalid",
+            message: "go.mod exceeds the discovery size limit."
+        };
+    }
+    catch {
+        return {
+            kind: "invalid",
+            message: "go.mod could not be read as a regular file."
+        };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function hasOneModuleDirective(source) {
+    if (source.includes("\0") || source.includes("\uFFFD")) {
+        return false;
+    }
+    const moduleLines = source.split(/\r?\n/u).filter((line) => (/^\s*module(?:\s|$)/u.test(line)));
+    return (moduleLines.length === 1 &&
+        /^\s*module\s+\S+\s*(?:(?:\/\/).*)?$/u.test(moduleLines[0] ?? ""));
+}
+function fileEvidence(detail) {
+    return { kind: "file", path: "go.mod", detail };
+}
+function userDecision(reason, message, evidence) {
+    return {
+        kind: "user-decision",
+        adapter: "go",
+        reason,
+        message,
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+function goTestProposal(evidence) {
+    return {
+        id: "go:test",
+        command: "go",
+        args: ["test", "./..."],
+        cwd: ".",
+        required: true,
+        evidence: { kind: "test-count", minimum: 1 },
+        sourceEvidence: evidence,
+        confidence: "high",
+        confirmed: false
+    };
+}
+export async function discoverGoProject(root) {
+    const metadata = await readGoMod(path.join(root, "go.mod"));
+    if (metadata.kind === "missing") {
+        return {
+            kind: "no-match",
+            adapter: "go",
+            reason: "not-go-project",
+            message: "No go.mod was found.",
+            evidence: [],
+            manualConfigAllowed: true
+        };
+    }
+    const evidence = [fileEvidence("Found bounded Go module metadata.")];
+    if (metadata.kind === "invalid") {
+        return userDecision("invalid-manifest", metadata.message, evidence);
+    }
+    if (!hasOneModuleDirective(metadata.source)) {
+        return userDecision("invalid-manifest", "go.mod does not contain one valid module directive.", evidence);
+    }
+    const proposalEvidence = [
+        fileEvidence("Found one explicit Go module directive.")
+    ];
+    return {
+        kind: "proposals",
+        adapter: "go",
+        proposals: [goTestProposal(proposalEvidence)],
+        evidence: proposalEvidence,
+        manualConfigAllowed: true
+    };
+}
+export const goDiscoveryAdapter = {
+    id: "go",
+    discover: discoverGoProject
+};