cloving 0.3.20 → 1.1.0

package/dist/src/daemon/delivery-router.js

@@ -0,0 +1,34 @@
+const refused = {
+    kind: "failed",
+    reason: "unsupported-effect",
+};
+function protectedEffect(intent) {
+    return intent.kind === "protected-effect";
+}
+function workerOf(routes, intent) {
+    const capability = String(intent.capability);
+    return Object.hasOwn(routes.effects, capability)
+        ? routes.effects[capability]
+        : undefined;
+}
+export function deliveryRouter(routes) {
+    const { runs } = routes;
+    const refusal = () => Promise.resolve(refused);
+    return {
+        deliver: (intent, signal) => {
+            if (!protectedEffect(intent))
+                return runs.deliver(intent);
+            return workerOf(routes, intent)?.deliver(intent, signal) ?? refusal();
+        },
+        reconcile: (intent, signal) => {
+            if (!protectedEffect(intent))
+                return runs.reconcile(intent);
+            return workerOf(routes, intent)?.reconcile(intent, signal) ?? refusal();
+        },
+        stop: (intent, signal) => {
+            if (!protectedEffect(intent))
+                return runs.stop(intent);
+            return workerOf(routes, intent)?.stop(intent, signal) ?? refusal();
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+export declare const reviewer = "greptile-apps[bot]";
+export declare const reviewLimits: {
+    summaryCharacters: number;
+    findingCharacters: number;
+    findingsBytes: number;
+};
+export interface CallSettings {
+    readonly repository: string;
+    readonly gh: readonly string[];
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly privateTexts?: readonly string[];
+}
+export interface Calls {
+    readonly gh: (parts: readonly string[]) => Promise<string>;
+    readonly git: (directory: string, parts: readonly string[]) => Promise<string>;
+    readonly run: (command: readonly string[], directory: string) => Promise<string>;
+}
+export interface Scored {
+    readonly score: number;
+    readonly summary: string;
+}
+export interface Finding {
+    readonly path: string;
+    readonly line: number | null;
+    readonly body: string;
+}
+export declare function calls(settings: CallSettings, signal: AbortSignal): Calls;
+export declare function scoreOf(comments: unknown, commit: string): Scored | undefined;
+export declare function findingsOf(comments: unknown, commit: string): readonly Finding[];

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 {};