@kylecheng3146/agent-ops 0.0.1

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

@@ -0,0 +1,40 @@
+import { goDiscoveryAdapter } from "./go.js";
+import { makeDiscoveryAdapter } from "./make.js";
+import { nodeDiscoveryAdapter } from "./node.js";
+import { pythonDiscoveryAdapter } from "./python.js";
+import { rustDiscoveryAdapter } from "./rust.js";
+const DEFAULT_ADAPTERS = [
+    nodeDiscoveryAdapter,
+    pythonDiscoveryAdapter,
+    goDiscoveryAdapter,
+    rustDiscoveryAdapter,
+    makeDiscoveryAdapter
+];
+export async function discoverProject(root, adapters = DEFAULT_ADAPTERS) {
+    const results = await Promise.all(adapters.map(async (adapter) => await adapter.discover(root)));
+    const matched = results.filter((result) => result.kind !== "no-match");
+    const evidence = results.flatMap((result) => result.evidence);
+    if (matched.length > 0) {
+        return {
+            kind: "project",
+            adapters: matched.map((result) => result.adapter),
+            proposals: matched.flatMap((result) => result.kind === "proposals" ? result.proposals : []),
+            decisions: matched.filter((result) => result.kind === "user-decision"),
+            evidence,
+            manualConfigAllowed: true
+        };
+    }
+    return {
+        kind: "no-match",
+        adapter: "orchestrator",
+        reason: "unsupported-stack",
+        message: "No supported technology stack was detected.",
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+export { discoverGoProject, goDiscoveryAdapter } from "./go.js";
+export { discoverMakeProject, makeDiscoveryAdapter } from "./make.js";
+export { discoverNodeProject, nodeDiscoveryAdapter } from "./node.js";
+export { discoverPythonProject, pythonDiscoveryAdapter } from "./python.js";
+export { discoverRustProject, rustDiscoveryAdapter } from "./rust.js";

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

@@ -0,0 +1,162 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+const MAX_MAKEFILE_BYTES = 1024 * 1024;
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+async function readMakefile(filePath) {
+    let status;
+    try {
+        status = await lstat(filePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return { kind: "missing" };
+        }
+        return {
+            kind: "invalid",
+            message: "Makefile could not be inspected safely."
+        };
+    }
+    if (status.isSymbolicLink() || !status.isFile()) {
+        return {
+            kind: "invalid",
+            message: "Makefile must be a regular file."
+        };
+    }
+    if (status.size > MAX_MAKEFILE_BYTES) {
+        return {
+            kind: "invalid",
+            message: "Makefile 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: "Makefile must remain a regular file."
+            };
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        while (totalBytes <= MAX_MAKEFILE_BYTES) {
+            const remaining = MAX_MAKEFILE_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: "Makefile exceeds the discovery size limit."
+        };
+    }
+    catch {
+        return {
+            kind: "invalid",
+            message: "Makefile could not be read as a regular file."
+        };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function literalTarget(source) {
+    if (source.includes("\0") || source.includes("\uFFFD")) {
+        return null;
+    }
+    const lines = source.split(/\r?\n/u);
+    if (lines.some((line) => /^test[ \t]*:(?![:=])/u.test(line))) {
+        return "test";
+    }
+    if (lines.some((line) => /^check[ \t]*:(?![:=])/u.test(line))) {
+        return "check";
+    }
+    return null;
+}
+function fileEvidence(target, detail) {
+    return {
+        kind: "file",
+        path: `Makefile#target:${target}`,
+        detail
+    };
+}
+function userDecision(reason, message, evidence) {
+    return {
+        kind: "user-decision",
+        adapter: "make",
+        reason,
+        message,
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+function makeProposal(target, evidence) {
+    return {
+        id: `make:${target}`,
+        command: "make",
+        args: [target],
+        cwd: ".",
+        required: true,
+        evidence: target === "test"
+            ? { kind: "test-count", minimum: 1 }
+            : { kind: "exit-code" },
+        sourceEvidence: evidence,
+        confidence: target === "test" ? "high" : "medium",
+        confirmed: false
+    };
+}
+export async function discoverMakeProject(root) {
+    const metadata = await readMakefile(path.join(root, "Makefile"));
+    if (metadata.kind === "missing") {
+        return {
+            kind: "no-match",
+            adapter: "make",
+            reason: "not-make-project",
+            message: "No Makefile was found.",
+            evidence: [],
+            manualConfigAllowed: true
+        };
+    }
+    const genericEvidence = [{
+            kind: "file",
+            path: "Makefile",
+            detail: "Found bounded Make metadata."
+        }];
+    if (metadata.kind === "invalid") {
+        return userDecision("invalid-manifest", metadata.message, genericEvidence);
+    }
+    if (metadata.source.includes("\0") || metadata.source.includes("\uFFFD")) {
+        return userDecision("invalid-manifest", "Makefile contains malformed text metadata.", genericEvidence);
+    }
+    const target = literalTarget(metadata.source);
+    if (target === null) {
+        return userDecision("no-known-commands", "No literal test or check target was found.", genericEvidence);
+    }
+    const proposalEvidence = [
+        fileEvidence(target, `Found literal ${target} target.`)
+    ];
+    return {
+        kind: "proposals",
+        adapter: "make",
+        proposals: [makeProposal(target, proposalEvidence)],
+        evidence: proposalEvidence,
+        manualConfigAllowed: true
+    };
+}
+export const makeDiscoveryAdapter = {
+    id: "make",
+    discover: discoverMakeProject
+};

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

@@ -0,0 +1,175 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+const LOCKFILES = [
+    { path: "bun.lock", packageManager: "bun" },
+    { path: "bun.lockb", packageManager: "bun" },
+    { path: "npm-shrinkwrap.json", packageManager: "npm" },
+    { path: "package-lock.json", packageManager: "npm" },
+    { path: "pnpm-lock.yaml", packageManager: "pnpm" },
+    { path: "yarn.lock", packageManager: "yarn" }
+];
+const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+async function fileExists(filePath) {
+    try {
+        const status = await lstat(filePath);
+        return status.isFile() && !status.isSymbolicLink();
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readBoundedPackageJson(filePath) {
+    let handle;
+    try {
+        handle = await open(filePath, constants.O_RDONLY |
+            constants.O_NOFOLLOW |
+            constants.O_NONBLOCK);
+        const status = await handle.stat();
+        if (!status.isFile()) {
+            return null;
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        while (totalBytes <= MAX_PACKAGE_JSON_BYTES) {
+            const remaining = MAX_PACKAGE_JSON_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 Buffer.concat(chunks, totalBytes).toString("utf8");
+            }
+            chunks.push(buffer.subarray(0, bytesRead));
+            totalBytes += bytesRead;
+        }
+        return null;
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ELOOP") ||
+            hasErrorCode(error, "EMLINK")) {
+            return null;
+        }
+        throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function readPackageScripts(value) {
+    if (!isRecord(value) || !isRecord(value.scripts)) {
+        return {};
+    }
+    const scripts = {};
+    for (const [name, command] of Object.entries(value.scripts)) {
+        if (typeof command === "string" && command.trim().length > 0) {
+            scripts[name] = command;
+        }
+    }
+    return scripts;
+}
+function fileEvidence(filePath, detail) {
+    return { kind: "file", path: filePath, detail };
+}
+function userDecision(reason, message, evidence) {
+    return {
+        kind: "user-decision",
+        adapter: "node",
+        reason,
+        message,
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+function createTestProposal(packageManager, lockfileEvidence) {
+    const args = packageManager === "bun" ? ["run", "test"] : ["test"];
+    return {
+        id: "node:test",
+        command: packageManager,
+        args,
+        cwd: ".",
+        required: true,
+        evidence: { kind: "test-count", minimum: 1 },
+        sourceEvidence: [
+            ...lockfileEvidence,
+            {
+                kind: "package-script",
+                path: "package.json#scripts.test",
+                detail: "Found an explicit test script."
+            }
+        ],
+        confidence: "high",
+        confirmed: false
+    };
+}
+async function detectLockfiles(root) {
+    const detected = await Promise.all(LOCKFILES.map(async (definition) => (await fileExists(path.join(root, definition.path))
+        ? definition
+        : null)));
+    return detected.filter((definition) => definition !== null);
+}
+export async function discoverNodeProject(root) {
+    const packageJsonPath = path.join(root, "package.json");
+    if (!await fileExists(packageJsonPath)) {
+        return {
+            kind: "no-match",
+            adapter: "node",
+            reason: "not-node-project",
+            message: "No package.json was found.",
+            evidence: [],
+            manualConfigAllowed: true
+        };
+    }
+    const packageEvidence = fileEvidence("package.json", "Found Node package metadata.");
+    let packageJson;
+    try {
+        const source = await readBoundedPackageJson(packageJsonPath);
+        if (source === null) {
+            return userDecision("invalid-package-json", "package.json is unsafe or exceeds the discovery size limit.", [packageEvidence]);
+        }
+        packageJson = JSON.parse(source);
+    }
+    catch {
+        return userDecision("invalid-package-json", "package.json could not be parsed; choose verifier commands manually.", [packageEvidence]);
+    }
+    const detectedLockfiles = await detectLockfiles(root);
+    const lockfileEvidence = detectedLockfiles.map((definition) => fileEvidence(definition.path, `Detected ${definition.packageManager} lockfile.`));
+    const packageManagers = [
+        ...new Set(detectedLockfiles.map((definition) => definition.packageManager))
+    ];
+    if (packageManagers.length === 0) {
+        return userDecision("missing-lockfile", "No recognized package-manager lockfile was found.", [packageEvidence]);
+    }
+    if (packageManagers.length > 1) {
+        return userDecision("multiple-package-managers", "Multiple package managers were detected; select one explicitly.", lockfileEvidence);
+    }
+    const scripts = readPackageScripts(packageJson);
+    if (scripts.test === undefined) {
+        return userDecision("no-known-scripts", "No recognized verification script was found.", [packageEvidence, ...lockfileEvidence]);
+    }
+    const packageManager = packageManagers[0];
+    if (packageManager === undefined) {
+        return userDecision("missing-lockfile", "No recognized package-manager lockfile was found.", [packageEvidence]);
+    }
+    return {
+        kind: "proposals",
+        adapter: "node",
+        packageManager,
+        proposals: [createTestProposal(packageManager, lockfileEvidence)],
+        evidence: [packageEvidence, ...lockfileEvidence],
+        manualConfigAllowed: true
+    };
+}
+export const nodeDiscoveryAdapter = {
+    id: "node",
+    discover: discoverNodeProject
+};

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

@@ -0,0 +1,163 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+const MAX_PYPROJECT_BYTES = 1024 * 1024;
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+async function readPyproject(filePath) {
+    let status;
+    try {
+        status = await lstat(filePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return { kind: "missing" };
+        }
+        return {
+            kind: "invalid",
+            message: "pyproject.toml could not be inspected safely."
+        };
+    }
+    if (status.isSymbolicLink() || !status.isFile()) {
+        return {
+            kind: "invalid",
+            message: "pyproject.toml must be a regular file."
+        };
+    }
+    if (status.size > MAX_PYPROJECT_BYTES) {
+        return {
+            kind: "invalid",
+            message: "pyproject.toml 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: "pyproject.toml must remain a regular file."
+            };
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        while (totalBytes <= MAX_PYPROJECT_BYTES) {
+            const remaining = MAX_PYPROJECT_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: "pyproject.toml exceeds the discovery size limit."
+        };
+    }
+    catch {
+        return {
+            kind: "invalid",
+            message: "pyproject.toml could not be read as a regular file."
+        };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function hasMalformedTableHeader(source) {
+    if (source.includes("\0") || source.includes("\uFFFD")) {
+        return true;
+    }
+    for (const rawLine of source.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line.startsWith("[")) {
+            continue;
+        }
+        const tablePattern = line.startsWith("[[")
+            ? /^\[\[[A-Za-z0-9_.-]+\]\](?:\s+#.*)?$/u
+            : /^\[[A-Za-z0-9_.-]+\](?:\s+#.*)?$/u;
+        if (!tablePattern.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasExplicitPytestEvidence(source) {
+    return source.split(/\r?\n/u).some((line) => (/^\s*\[tool\.pytest\.ini_options\]\s*(?:#.*)?$/u.test(line)));
+}
+function fileEvidence(detail) {
+    return { kind: "file", path: "pyproject.toml", detail };
+}
+function userDecision(reason, message, evidence) {
+    return {
+        kind: "user-decision",
+        adapter: "python",
+        reason,
+        message,
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+function pytestProposal(evidence) {
+    return {
+        id: "python:pytest",
+        command: "python",
+        args: ["-m", "pytest"],
+        cwd: ".",
+        required: true,
+        evidence: { kind: "test-count", minimum: 1 },
+        sourceEvidence: evidence,
+        confidence: "high",
+        confirmed: false
+    };
+}
+export async function discoverPythonProject(root) {
+    const metadata = await readPyproject(path.join(root, "pyproject.toml"));
+    if (metadata.kind === "missing") {
+        return {
+            kind: "no-match",
+            adapter: "python",
+            reason: "not-python-project",
+            message: "No pyproject.toml was found.",
+            evidence: [],
+            manualConfigAllowed: true
+        };
+    }
+    const evidence = [
+        fileEvidence("Found bounded Python project metadata.")
+    ];
+    if (metadata.kind === "invalid") {
+        return userDecision("invalid-manifest", metadata.message, evidence);
+    }
+    if (hasMalformedTableHeader(metadata.source)) {
+        return userDecision("invalid-manifest", "pyproject.toml contains malformed table metadata.", evidence);
+    }
+    if (!hasExplicitPytestEvidence(metadata.source)) {
+        return userDecision("no-known-commands", "No explicit pytest configuration was found.", evidence);
+    }
+    const proposalEvidence = [
+        fileEvidence("Found explicit [tool.pytest.ini_options] evidence.")
+    ];
+    return {
+        kind: "proposals",
+        adapter: "python",
+        proposals: [pytestProposal(proposalEvidence)],
+        evidence: proposalEvidence,
+        manualConfigAllowed: true
+    };
+}
+export const pythonDiscoveryAdapter = {
+    id: "python",
+    discover: discoverPythonProject
+};

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

@@ -0,0 +1,159 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+const MAX_CARGO_TOML_BYTES = 1024 * 1024;
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+async function readCargoToml(filePath) {
+    let status;
+    try {
+        status = await lstat(filePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return { kind: "missing" };
+        }
+        return {
+            kind: "invalid",
+            message: "Cargo.toml could not be inspected safely."
+        };
+    }
+    if (status.isSymbolicLink() || !status.isFile()) {
+        return {
+            kind: "invalid",
+            message: "Cargo.toml must be a regular file."
+        };
+    }
+    if (status.size > MAX_CARGO_TOML_BYTES) {
+        return {
+            kind: "invalid",
+            message: "Cargo.toml 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: "Cargo.toml must remain a regular file."
+            };
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        while (totalBytes <= MAX_CARGO_TOML_BYTES) {
+            const remaining = MAX_CARGO_TOML_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: "Cargo.toml exceeds the discovery size limit."
+        };
+    }
+    catch {
+        return {
+            kind: "invalid",
+            message: "Cargo.toml could not be read as a regular file."
+        };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function hasMalformedTableHeader(source) {
+    if (source.includes("\0") || source.includes("\uFFFD")) {
+        return true;
+    }
+    for (const rawLine of source.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line.startsWith("[")) {
+            continue;
+        }
+        const tablePattern = line.startsWith("[[")
+            ? /^\[\[[A-Za-z0-9_.-]+\]\](?:\s+#.*)?$/u
+            : /^\[[A-Za-z0-9_.-]+\](?:\s+#.*)?$/u;
+        if (!tablePattern.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasCargoRootEvidence(source) {
+    return source.split(/\r?\n/u).some((line) => (/^\s*\[(?:package|workspace)\]\s*(?:#.*)?$/u.test(line)));
+}
+function fileEvidence(detail) {
+    return { kind: "file", path: "Cargo.toml", detail };
+}
+function userDecision(reason, message, evidence) {
+    return {
+        kind: "user-decision",
+        adapter: "rust",
+        reason,
+        message,
+        evidence,
+        manualConfigAllowed: true
+    };
+}
+function cargoTestProposal(evidence) {
+    return {
+        id: "rust:cargo-test",
+        command: "cargo",
+        args: ["test"],
+        cwd: ".",
+        required: true,
+        evidence: { kind: "test-count", minimum: 1 },
+        sourceEvidence: evidence,
+        confidence: "high",
+        confirmed: false
+    };
+}
+export async function discoverRustProject(root) {
+    const metadata = await readCargoToml(path.join(root, "Cargo.toml"));
+    if (metadata.kind === "missing") {
+        return {
+            kind: "no-match",
+            adapter: "rust",
+            reason: "not-rust-project",
+            message: "No Cargo.toml was found.",
+            evidence: [],
+            manualConfigAllowed: true
+        };
+    }
+    const evidence = [fileEvidence("Found bounded Cargo metadata.")];
+    if (metadata.kind === "invalid") {
+        return userDecision("invalid-manifest", metadata.message, evidence);
+    }
+    if (hasMalformedTableHeader(metadata.source)) {
+        return userDecision("invalid-manifest", "Cargo.toml contains malformed table metadata.", evidence);
+    }
+    if (!hasCargoRootEvidence(metadata.source)) {
+        return userDecision("no-known-commands", "No explicit Cargo package or workspace was found.", evidence);
+    }
+    const proposalEvidence = [
+        fileEvidence("Found explicit Cargo package or workspace evidence.")
+    ];
+    return {
+        kind: "proposals",
+        adapter: "rust",
+        proposals: [cargoTestProposal(proposalEvidence)],
+        evidence: proposalEvidence,
+        manualConfigAllowed: true
+    };
+}
+export const rustDiscoveryAdapter = {
+    id: "rust",
+    discover: discoverRustProject
+};

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

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