cloving 0.3.19 → 1.0.1

package/dist/src/daemon/github-calls.js

@@ -0,0 +1,127 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const executed = promisify(execFile);
+const outputBytes = 16 * 1024 * 1024;
+const scorePattern = /greptile_confidence_score:\s*(\d+)/;
+const commitPattern = /Last reviewed commit:[^\n]*?\/commit\/([0-9a-f]{7,40})/;
+export const reviewer = "greptile-apps[bot]";
+export const reviewLimits = {
+    summaryCharacters: 4_000,
+    findingCharacters: 3_000,
+    findingsBytes: 12_000,
+};
+function privateEnvironment(environment) {
+    try {
+        const value = JSON.parse(environment["CLOVING_PRIVATE_TEXTS"] ?? "[]");
+        return list(value).filter((item) => typeof item === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function failureDetail(error, place) {
+    const stderr = field(error, "stderr");
+    const text = typeof stderr === "string" ? stderr : "";
+    const secrets = Object.entries(place.environment)
+        .filter(([name]) => /TOKEN|SECRET|PASSWORD|KEY/i.test(name))
+        .map(([, value]) => value);
+    const hidden = [...secrets, ...place.privateTexts]
+        .filter((value) => typeof value === "string" && value !== "")
+        .sort((left, right) => right.length - left.length);
+    const detail = hidden.reduce((redacted, value) => redacted.replaceAll(value, "[hidden]"), text);
+    return {
+        detail: detail.slice(-2_000),
+        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
+    };
+}
+async function output(command, place) {
+    try {
+        const { stdout } = await executed(String(command[0]), command.slice(1), {
+            cwd: place.directory,
+            env: place.environment,
+            signal: place.signal,
+            maxBuffer: outputBytes,
+        });
+        return stdout;
+    }
+    catch (error) {
+        const failure = new Error(place.reason, { cause: error });
+        if (place.reason === "check-failed")
+            throw failure;
+        throw Object.assign(failure, failureDetail(error, place));
+    }
+}
+export function calls(settings, signal) {
+    const environment = { ...process.env, ...settings.environment };
+    const privateTexts = [
+        ...(settings.privateTexts ?? []),
+        ...privateEnvironment(environment),
+    ];
+    const place = (directory, reason) => ({
+        directory,
+        signal,
+        environment,
+        reason,
+        privateTexts,
+    });
+    return {
+        gh: (parts) => output([...settings.gh, ...parts], place(settings.repository, "github-call-failed")),
+        git: (directory, parts) => output(["git", ...parts], place(directory, "git-call-failed")),
+        run: (command, directory) => output(command, place(directory, "check-failed")),
+    };
+}
+function field(value, name) {
+    return Reflect.get(Object(value), name);
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+function byReviewer(comment) {
+    return field(field(comment, "user"), "login") === reviewer;
+}
+function scored(body, commit) {
+    const score = scorePattern.exec(body)?.[1];
+    const reviewed = commitPattern.exec(body)?.[1];
+    if (score === undefined || reviewed === undefined)
+        return undefined;
+    if (!commit.startsWith(reviewed))
+        return undefined;
+    const summary = body
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .trim()
+        .slice(0, reviewLimits.summaryCharacters);
+    return { score: Number(score), summary };
+}
+export function scoreOf(comments, commit) {
+    return list(comments)
+        .filter(byReviewer)
+        .map((comment) => scored(String(field(comment, "body")), commit))
+        .findLast((item) => item !== undefined);
+}
+function findingOf(comment) {
+    const line = field(comment, "line") ?? field(comment, "original_line");
+    return {
+        path: String(field(comment, "path")),
+        line: typeof line === "number" ? line : null,
+        body: String(field(comment, "body")).slice(0, reviewLimits.findingCharacters),
+    };
+}
+function reviewed(comment, commit) {
+    return (byReviewer(comment) &&
+        field(comment, "original_commit_id") === commit &&
+        typeof field(comment, "in_reply_to_id") !== "number");
+}
+export function findingsOf(comments, commit) {
+    const kept = [];
+    let bytes = 0;
+    for (const comment of list(comments)) {
+        if (!reviewed(comment, commit))
+            continue;
+        const finding = findingOf(comment);
+        bytes += Buffer.byteLength(JSON.stringify(finding));
+        if (bytes > reviewLimits.findingsBytes)
+            break;
+        kept.push(finding);
+    }
+    return kept;
+}

package/dist/src/daemon/github-issue-methods.d.ts

@@ -0,0 +1,3 @@
+import { type Operation } from "./github-operation.ts";
+export declare function createIssue(operation: Operation): Promise<unknown>;
+export declare function discard(operation: Operation): Promise<unknown>;

package/dist/src/daemon/github-issue-methods.js

@@ -0,0 +1,99 @@
+import { existsSync } from "node:fs";
+import { lstat, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { existingTree, removeWorktree, repositoryPath, text, } from "./github-operation.js";
+import { writeRecord } from "./operation-journal.js";
+import { treePlace } from "./work-tree.js";
+import { issuePrivacy, operatorPrivateTexts } from "./github-issue-privacy.js";
+function issueFromUrl(url) {
+    const number = Number(/^https?:\/\/[^/\s]+\/[\w.-]+\/[\w.-]+\/issues\/([1-9]\d*)$/.exec(url)?.[1]);
+    if (!Number.isSafeInteger(number) || number < 1)
+        throw new Error("github-call-failed");
+    return { number, url };
+}
+function issueOf(issue) {
+    if (typeof issue !== "object" ||
+        issue === null ||
+        !("number" in issue) ||
+        typeof issue.number !== "number" ||
+        !("html_url" in issue) ||
+        typeof issue.html_url !== "string")
+        throw new Error("github-call-failed");
+    const parsed = issueFromUrl(issue.html_url);
+    if (issue.number !== parsed.number)
+        throw new Error("github-call-failed");
+    return parsed;
+}
+function issuePage(line) {
+    const page = JSON.parse(line);
+    if (!Array.isArray(page))
+        throw new Error("github-call-failed");
+    return page.map((issue) => issueOf(issue));
+}
+function repositoryName(reply) {
+    const repository = JSON.parse(reply);
+    if (typeof repository !== "object" ||
+        repository === null ||
+        !("nameWithOwner" in repository) ||
+        typeof repository.nameWithOwner !== "string" ||
+        !/^[\w.-]+\/[\w.-]+$/.test(repository.nameWithOwner))
+        throw new Error("github-call-failed");
+    return repository.nameWithOwner;
+}
+async function draftOf(operation) {
+    const name = text(operation, "draft");
+    if (basename(name) !== name || name.includes("\\"))
+        throw new Error("invalid-draft");
+    const path = join(existingTree(operation).path, name);
+    const stat = await lstat(path).catch(() => undefined);
+    if (stat === undefined || !stat.isFile())
+        throw new Error("draft-not-available");
+    return readFile(path, "utf8");
+}
+async function knownIssue(operation, marker) {
+    const output = await operation.calls.gh([
+        "api",
+        "--paginate",
+        `${repositoryPath}/issues?state=all&per_page=100`,
+        "--jq",
+        `[.[] | select((.body // "") | contains(${JSON.stringify(marker)})) | {number, html_url}] | @json`,
+    ]);
+    return output.trim().split("\n").flatMap(issuePage)[0];
+}
+export async function createIssue(operation) {
+    operatorPrivateTexts(operation.settings);
+    const draft = await draftOf(operation);
+    const [heading = "", ...lines] = draft.split("\n");
+    if (!heading.startsWith("# ") || heading.slice(2).trim() === "")
+        throw new Error("invalid-draft");
+    const repository = repositoryName(await operation.calls.gh(["repo", "view", "--json", "nameWithOwner"]));
+    issuePrivacy(draft, {
+        settings: operation.settings,
+        repository,
+    });
+    const marker = `<!-- cloving-prd:${operation.target} -->`;
+    const known = await knownIssue(operation, marker);
+    if (known !== undefined)
+        return known;
+    if (existsSync(join(operation.folder, "post.json")))
+        throw new Error("post-uncertain");
+    await writeRecord(operation.folder, { name: "post.json", value: { marker } });
+    const printed = await operation.calls.gh([
+        "issue",
+        "create",
+        "--title",
+        heading.slice(2).trim(),
+        "--body",
+        `${lines.join("\n")}\n${marker}`,
+    ]);
+    const url = printed.trim().split("\n").at(-1) ?? "";
+    return issueFromUrl(url);
+}
+export async function discard(operation) {
+    const place = treePlace({
+        worktrees: operation.settings.worktrees,
+        target: operation.target,
+    });
+    await removeWorktree(operation, place);
+    return { discarded: place.branch };
+}

package/dist/src/daemon/github-issue-privacy.d.ts

@@ -0,0 +1,6 @@
+import type { MethodSettings } from "./github-operation.ts";
+export declare function issuePrivacy(text: string, options: {
+    readonly settings: MethodSettings;
+    readonly repository: string;
+}): void;
+export declare function operatorPrivateTexts(settings: MethodSettings): readonly string[];

package/dist/src/daemon/github-issue-privacy.js

@@ -0,0 +1,131 @@
+import { homedir } from "node:os";
+import { decodeHTMLStrict } from "entities/decode";
+function entity(value) {
+    const encoded = `&${value};`;
+    const decoded = decodeHTMLStrict(encoded);
+    if (decoded === encoded)
+        throw new Error("private-path-in-change");
+    return decoded.replace(/\u00a0/g, " ");
+}
+function decoded(text) {
+    return text
+        .replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]+);/gi, (_match, value) => entity(value))
+        .replace(/(?:%[\da-f]{2})+/gi, (value) => {
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            return value.replace(/%([\da-f]{2})/gi, (_match, code) => String.fromCharCode(Number.parseInt(code, 16)));
+        }
+    });
+}
+function linkEnd(text, opening) {
+    const closing = opening.mark === "[" ? "]" : ")";
+    let depth = 0;
+    for (let index = opening.index; index < text.length; index += 1) {
+        const character = text[index];
+        if (character === opening.mark)
+            depth += 1;
+        if (character === closing)
+            depth -= 1;
+        if (depth === 0)
+            return index;
+    }
+    return undefined;
+}
+function ambiguousDestination(text) {
+    return /["'<]/.test(text.replace(/"[^"]*"|'[^']*'|<[^>]*>/g, ""));
+}
+function visibleLinks(text) {
+    let result = "";
+    let cursor = 0;
+    let position = 0;
+    for (;;) {
+        const start = text.indexOf("[", position);
+        if (start === -1)
+            break;
+        const labelEnd = linkEnd(text, { index: start, mark: "[" });
+        if (labelEnd === undefined) {
+            position = start + 1;
+            continue;
+        }
+        const mark = text[labelEnd + 1];
+        if (mark !== "(" && mark !== "[") {
+            position = start + 1;
+            continue;
+        }
+        const end = linkEnd(text, { index: labelEnd + 1, mark });
+        if (end === undefined)
+            throw new Error("private-path-in-change");
+        if (mark === "(" && ambiguousDestination(text.slice(labelEnd + 2, end)))
+            throw new Error("private-path-in-change");
+        result += text.slice(cursor, start) + text.slice(start + 1, labelEnd);
+        cursor = end + 1;
+        position = cursor;
+    }
+    return result + text.slice(cursor);
+}
+function visible(text) {
+    return visibleLinks(text)
+        .replace(/<[^>]*>/g, "")
+        .replace(/[*`~[\]]/g, "");
+}
+function paths(text) {
+    const withoutUrls = text.replace(/https?:\/\/[^\s<>"')]+/gi, (url) => {
+        const query = url.search(/[?#]/);
+        return query === -1 ? "" : ` ${url.slice(query + 1)}`;
+    });
+    return [
+        /~\//,
+        /\.\.\//,
+        /[a-z]:[\\/]/i,
+        /\\\\[^\s\\]+\\[^\s\\]+/,
+        /(?:^|[^\p{L}\p{N}_./\\-])\/{1,2}[^/\s<>"'`]+\/[^\s<>"'`]+/u,
+    ].some((pattern) => pattern.test(withoutUrls));
+}
+function unsafeLinks(text) {
+    const links = text.matchAll(/(?:\]\(\s*<?|<|^\s{0,3}\[[^\]]+\]:\s*<?|\b(?:href|src)\s*=\s*["']?\s*)([a-z][\w+.-]*):|\b([a-z][\w+.-]*):\/\//gim);
+    return [...links].some((match) => !["http", "https"].includes(String(match[1] ?? match[2]).toLowerCase()));
+}
+function mentions(text) {
+    return [...text.matchAll(/(?:^|[^\w@])@([a-z\d][a-z\d-]*)(\/)?/gi)].some((match) => match[2] !== "/");
+}
+function foreignIssues(text, repository) {
+    const references = [
+        ...text.matchAll(/\b([\w.-]+\/[\w.-]+)#\d+/g),
+        ...text.matchAll(/https?:\/\/[^/\s]+\/([\w.-]+\/[\w.-]+)\/(?:issues|pull)\/\d+/gi),
+    ];
+    return references.some((match) => match[1]?.toLowerCase() !== repository.toLowerCase());
+}
+function privateText(text, options) {
+    const lowered = text.toLowerCase();
+    return (options.texts.some((item) => lowered.includes(item.toLowerCase())) ||
+        /gh[pousr]_|github_pat_|sk-ant-|-----BEGIN/i.test(text) ||
+        /[\w.!#$%&'*+/=?^`{|}~-]+@[\w.-]+\.[a-z]{2,}/i.test(text) ||
+        mentions(text) ||
+        paths(text) ||
+        unsafeLinks(text) ||
+        foreignIssues(text, options.repository));
+}
+export function issuePrivacy(text, options) {
+    const { settings, repository } = options;
+    const operatorTexts = operatorPrivateTexts(settings);
+    const texts = [
+        homedir(),
+        settings.repository,
+        settings.worktrees,
+        ...operatorTexts,
+    ];
+    const plain = decoded(text);
+    const unescaped = plain.replace(/\\([^\p{L}\p{N}\s])/gu, "$1");
+    const rendered = visible(unescaped);
+    const forms = [text, plain, unescaped, rendered, rendered.replace(/_/g, "")];
+    if (forms.some((form) => privateText(form, { texts, repository })))
+        throw new Error("private-path-in-change");
+}
+export function operatorPrivateTexts(settings) {
+    const texts = settings.privateTexts?.filter((item) => item.trim() !== "") ?? [];
+    if (texts.length === 0)
+        throw new Error("private-texts-not-set");
+    return texts;
+}

package/dist/src/daemon/github-merge.d.ts

@@ -0,0 +1,18 @@
+import { type Operation } from "./github-operation.ts";
+interface ReviewedPull {
+    readonly number: number;
+    readonly commit: string;
+}
+interface SuccessfulMerge {
+    readonly number: number;
+    readonly commit: string;
+    readonly updated: string;
+    readonly merged: string;
+}
+interface MergeRepair {
+    readonly reason: "check-failed" | "merge-conflict";
+    readonly output: string;
+}
+export type MergeResult = SuccessfulMerge | MergeRepair;
+export declare function merge(operation: Operation, pull: ReviewedPull): Promise<MergeResult>;
+export {};

package/dist/src/daemon/github-merge.js

@@ -0,0 +1,259 @@
+import { existsSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { readRecord, writeRecord } from "./operation-journal.js";
+import { changeChecked, defaultBranch, existingTree, field, githubTiming, removeWorktree, repositoryPath, } from "./github-operation.js";
+import { treePlace } from "./work-tree.js";
+function commitOf(value, name) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("github-call-failed");
+    const commit = Reflect.get(value, name);
+    if (typeof commit !== "string")
+        throw new Error("github-call-failed");
+    return commit;
+}
+async function knownMerge(operation, expected) {
+    const pull = JSON.parse(await operation.calls.gh([
+        "api",
+        `${repositoryPath}/pulls/${String(expected.number)}`,
+    ]));
+    const head = commitOf(field(pull, "head"), "sha");
+    if (field(pull, "merged") !== true)
+        return { head, merged: undefined };
+    if (head !== expected.commit && head !== expected.updated)
+        throw new Error("merged-other-commit");
+    return { head, merged: commitOf(pull, "merge_commit_sha") };
+}
+async function abortMerge(operation, tree) {
+    const path = (await operation.calls.git(tree.path, [
+        "rev-parse",
+        "--git-path",
+        "MERGE_HEAD",
+    ])).trim();
+    if (existsSync(path))
+        await operation.calls.git(tree.path, ["merge", "--abort"]);
+}
+async function restored(operation, place) {
+    await abortMerge(operation, place.tree);
+    await clean(operation, place.tree);
+    if ((await headOf(operation, place.tree)) === place.commit)
+        return;
+    await operation.calls.git(place.tree.path, ["reset", "--hard", place.commit]);
+}
+async function clean(operation, tree) {
+    const status = await operation.calls.git(tree.path, [
+        "status",
+        "--porcelain",
+        "--untracked-files=no",
+    ]);
+    if (status.trim() !== "")
+        throw new Error("uncommitted-change");
+}
+async function headOf(operation, tree) {
+    return (await operation.calls.git(tree.path, ["rev-parse", "HEAD"])).trim();
+}
+async function fetched(operation, base) {
+    const { calls, settings } = operation;
+    await calls.git(settings.repository, ["fetch", "--quiet", "origin"]);
+    return (await calls.git(settings.repository, ["rev-parse", `origin/${base}`])).trim();
+}
+async function updatedTree(operation, place) {
+    const { calls } = operation;
+    const ancestor = (await calls.git(place.tree.path, ["merge-base", "HEAD", place.base])).trim();
+    if (ancestor === place.base)
+        return;
+    try {
+        await calls.git(place.tree.path, [
+            "merge",
+            "--no-ff",
+            "--no-edit",
+            place.base,
+        ]);
+    }
+    catch {
+        const conflicts = await calls.git(place.tree.path, [
+            "diff",
+            "--name-only",
+            "--diff-filter=U",
+        ]);
+        await calls.git(place.tree.path, ["merge", "--abort"]);
+        throw new Error("merge-conflict", { cause: conflicts.trim() });
+    }
+}
+async function checked(operation, place) {
+    await changeChecked(operation, place);
+    const head = await headOf(operation, place.tree);
+    if (operation.settings.check !== undefined)
+        await operation.calls.run(operation.settings.check, place.tree.path);
+    await clean(operation, place.tree);
+    if ((await headOf(operation, place.tree)) !== head)
+        throw new Error("uncommitted-change");
+    if (head !== place.commit && operation.settings.check === undefined)
+        throw new Error("check-required");
+    return head;
+}
+async function refreshed(operation, place) {
+    await restored(operation, {
+        tree: place.tree,
+        commit: place.recorded ?? place.commit,
+    });
+    const base = await defaultBranch(operation);
+    let newest = await fetched(operation, base);
+    if (place.recorded !== undefined &&
+        (await operation.calls.git(place.tree.path, [
+            "merge-base",
+            place.recorded,
+            newest,
+        ])).trim() === newest)
+        return place.recorded;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        await updatedTree(operation, { tree: place.tree, base: newest });
+        const head = await checked(operation, { ...place, base });
+        const latest = await fetched(operation, base);
+        if (latest === newest)
+            return head;
+        newest = latest;
+    }
+    throw new Error("base-moved");
+}
+async function mergedNow(operation, pull) {
+    const reply = JSON.parse(await operation.calls.gh([
+        "api",
+        "-X",
+        "PUT",
+        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
+        "-f",
+        "merge_method=merge",
+        "-f",
+        `sha=${pull.commit}`,
+    ]));
+    return commitOf(reply, "sha");
+}
+async function waitForHead(operation, pull) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0; attempt < 30; attempt += 1) {
+        if (attempt > 0)
+            await delay(timing.pollMilliseconds, undefined, {
+                signal: operation.signal,
+            });
+        const current = JSON.parse(await operation.calls.gh([
+            "api",
+            `${repositoryPath}/pulls/${String(pull.number)}`,
+        ]));
+        if (commitOf(field(current, "head"), "sha") === pull.commit)
+            return;
+    }
+    throw new Error("head-not-updated");
+}
+async function mergeUpdated(operation, pull) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0;; attempt += 1) {
+        await waitForHead(operation, pull);
+        try {
+            return await mergedNow(operation, pull);
+        }
+        catch (error) {
+            const status = field(error, "status");
+            if (attempt === 2 || (status !== 405 && status !== 409))
+                throw error;
+            await delay(timing.pollMilliseconds, undefined, {
+                signal: operation.signal,
+            });
+        }
+    }
+}
+async function removed(operation, place) {
+    const { settings, calls } = operation;
+    await calls
+        .gh([
+        "api",
+        "-X",
+        "DELETE",
+        `${repositoryPath}/git/refs/heads/${place.branch}`,
+    ])
+        .catch(() => undefined);
+    await removeWorktree(operation, place);
+    await calls.git(settings.repository, [
+        "update-ref",
+        "-d",
+        `refs/remotes/origin/${place.branch}`,
+    ]);
+}
+async function recordedHead(operation, commit) {
+    const record = await readRecord(operation.folder, "updated-head.json");
+    if (record === undefined)
+        return undefined;
+    const updated = field(record, "updated");
+    if (field(record, "commit") !== commit ||
+        typeof updated !== "string" ||
+        !/^[0-9a-f]{40,64}$/.test(updated))
+        throw new Error("git-call-failed");
+    return updated;
+}
+async function readyHead(operation, pull) {
+    const tree = existingTree(operation);
+    const updated = await refreshed(operation, {
+        tree,
+        commit: pull.commit,
+        recorded: pull.recorded,
+    });
+    if (updated === pull.commit)
+        return updated;
+    if (pull.recorded !== updated)
+        await writeRecord(operation.folder, {
+            name: "updated-head.json",
+            value: { commit: pull.commit, updated },
+        });
+    if (pull.remote !== updated)
+        await operation.calls.git(tree.path, [
+            "push",
+            "--quiet",
+            "origin",
+            `${updated}:refs/heads/${tree.branch}`,
+        ]);
+    return updated;
+}
+function checkOutput(cause) {
+    return ["stdout", "stderr"]
+        .map((name) => {
+        const value = field(cause, name);
+        return typeof value === "string" ? value : "";
+    })
+        .join("")
+        .slice(-6_000);
+}
+export async function merge(operation, pull) {
+    try {
+        return await completedMerge(operation, pull);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        if (!(error instanceof Error))
+            throw error;
+        const reason = error.message;
+        if (reason !== "check-failed" && reason !== "merge-conflict")
+            throw error;
+        const conflicts = typeof error.cause === "string" ? error.cause : "";
+        return {
+            reason,
+            output: reason === "check-failed" ? checkOutput(error.cause) : conflicts,
+        };
+    }
+}
+async function completedMerge(operation, pull) {
+    const place = treePlace({
+        worktrees: operation.settings.worktrees,
+        target: operation.target,
+    });
+    const recorded = await recordedHead(operation, pull.commit);
+    const known = await knownMerge(operation, {
+        ...pull,
+        updated: recorded ?? pull.commit,
+    });
+    const updated = known.merged === undefined
+        ? await readyHead(operation, { ...pull, recorded, remote: known.head })
+        : (recorded ?? pull.commit);
+    const mergeCall = updated === pull.commit ? mergedNow : mergeUpdated;
+    const merged = known.merged ?? (await mergeCall(operation, { ...pull, commit: updated }));
+    await removed(operation, place);
+    return { number: pull.number, commit: pull.commit, updated, merged };
+}

package/dist/src/daemon/github-methods.d.ts

@@ -0,0 +1,5 @@
+import { type Operation } from "./github-operation.ts";
+export type { GithubTiming, MethodSettings } from "./github-operation.ts";
+export declare const methodReasons: ReadonlySet<string>;
+export type Method = (operation: Operation) => Promise<unknown>;
+export declare const methods: ReadonlyMap<string, Method>;