@devinnn/docdrift 0.1.0

package/dist/src/devin/prompts.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAutogenPrompt = buildAutogenPrompt;
+exports.buildConceptualPrompt = buildConceptualPrompt;
+function attachmentBlock(attachmentUrls) {
+    return attachmentUrls.map((url, index) => `- ATTACHMENT ${index + 1}: ${url}`).join("\n");
+}
+function buildAutogenPrompt(input) {
+    return [
+        "You are Devin. Task: update API reference docs to match actual code/spec changes.",
+        "",
+        "EVIDENCE (attachments):",
+        attachmentBlock(input.attachmentUrls),
+        "",
+        "Rules (hard):",
+        `1) Only modify files under: ${input.allowlist.join(", ")}`,
+        "2) Make the smallest change that makes docs correct.",
+        "3) Run verification commands and record results:",
+        ...input.verificationCommands.map((cmd) => `   - ${cmd}`),
+        "4) Open ONE pull request for this doc area with a clear title.",
+        "5) Keep a reviewer-friendly PR description: what changed, why docs were wrong, how to validate.",
+        "",
+        "Structured Output:",
+        "- Maintain structured output in the provided JSON schema.",
+        "- Update it immediately when you:",
+        "  a) finish planning (filesToEdit, summary, confidence),",
+        "  b) begin editing (status=EDITING),",
+        "  c) start/finish verification (status=VERIFYING + verification.results),",
+        "  d) open PR (status=OPENED_PR + pr.url),",
+        "  e) get blocked (status=BLOCKED + questions),",
+        "  f) complete (status=DONE).",
+        "",
+        `Goal: Produce a PR for doc area ${input.item.docArea} using only the evidence.`
+    ].join("\n");
+}
+function buildConceptualPrompt(input) {
+    return [
+        "You are Devin. Task: propose minimal edits to conceptual docs potentially impacted by code changes.",
+        "",
+        "EVIDENCE (attachments):",
+        attachmentBlock(input.attachmentUrls),
+        "",
+        "Rules (hard):",
+        `1) Only modify files under: ${input.allowlist.join(", ")}`,
+        "2) Do NOT invent product policy. If unclear, ask 2-3 targeted questions instead of guessing.",
+        `3) Prefer OPEN_ISSUE when confidence < ${input.confidenceThreshold.toFixed(2)}.`,
+        "4) If you open a PR, keep it extremely small and include a checklist of assumptions.",
+        "",
+        "Structured Output:",
+        "- Update at planning, editing, verifying, open-pr, blocked, done milestones.",
+        "- If blocked, fill blocked.questions with concrete, reviewer-actionable questions.",
+        "",
+        "Goal: either open a very small PR with confidence or open an issue/comment with crisp questions and suggested patch text."
+    ].join("\n");
+}

package/dist/src/devin/schemas.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatchResultSchema = exports.PatchPlanSchema = void 0;
+exports.PatchPlanSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "status",
+        "docArea",
+        "mode",
+        "confidence",
+        "summary",
+        "evidence",
+        "filesToEdit",
+        "verification",
+        "nextAction"
+    ],
+    properties: {
+        status: { enum: ["PLANNING", "EDITING", "VERIFYING", "OPENED_PR", "BLOCKED", "DONE"] },
+        docArea: { type: "string" },
+        mode: { enum: ["autogen", "conceptual"] },
+        confidence: { type: "number", minimum: 0, maximum: 1 },
+        summary: { type: "string" },
+        evidence: {
+            type: "object",
+            additionalProperties: false,
+            required: ["attachments", "diffSummary"],
+            properties: {
+                attachments: { type: "array", items: { type: "string" } },
+                diffSummary: { type: "string" }
+            }
+        },
+        filesToEdit: { type: "array", items: { type: "string" } },
+        verification: {
+            type: "object",
+            additionalProperties: false,
+            required: ["commands"],
+            properties: {
+                commands: { type: "array", items: { type: "string" } },
+                results: { type: "array", items: { type: "string" } }
+            }
+        },
+        nextAction: { enum: ["OPEN_PR", "OPEN_ISSUE", "NOOP"] },
+        pr: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                title: { type: "string" },
+                url: { type: "string" }
+            }
+        },
+        blocked: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                reason: { type: "string" },
+                questions: { type: "array", items: { type: "string" } }
+            }
+        }
+    }
+};
+exports.PatchResultSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["outcome", "confidence", "summary", "validation", "links"],
+    properties: {
+        outcome: { enum: ["PR_OPENED", "ISSUE_OPENED", "NO_CHANGE", "BLOCKED"] },
+        confidence: { type: "number", minimum: 0, maximum: 1 },
+        summary: { type: "string" },
+        changes: { type: "array", items: { type: "string" } },
+        validation: {
+            type: "object",
+            additionalProperties: false,
+            required: ["commands", "results"],
+            properties: {
+                commands: { type: "array", items: { type: "string" } },
+                results: { type: "array", items: { type: "string" } }
+            }
+        },
+        links: {
+            type: "object",
+            additionalProperties: false,
+            required: ["sessionUrl"],
+            properties: {
+                sessionUrl: { type: "string" },
+                prUrl: { type: "string" },
+                issueUrl: { type: "string" }
+            }
+        },
+        blocked: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                reason: { type: "string" },
+                questions: { type: "array", items: { type: "string" } }
+            }
+        }
+    }
+};

package/dist/src/devin/v1.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devinUploadAttachment = devinUploadAttachment;
+exports.devinCreateSession = devinCreateSession;
+exports.devinGetSession = devinGetSession;
+exports.devinListSessions = devinListSessions;
+exports.pollUntilTerminal = pollUntilTerminal;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function ensureOk(response, body, context) {
+    if (!response.ok) {
+        throw new Error(`${context} failed: ${response.status} ${body}`);
+    }
+}
+async function devinUploadAttachment(apiKey, filePath) {
+    const resolved = node_path_1.default.resolve(filePath);
+    const bytes = node_fs_1.default.readFileSync(resolved);
+    const blob = new Blob([bytes]);
+    const form = new FormData();
+    form.append("file", blob, node_path_1.default.basename(filePath));
+    const response = await fetch("https://api.devin.ai/v1/attachments", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`
+        },
+        body: form
+    });
+    const text = await response.text();
+    ensureOk(response, text, "Upload attachment");
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "string") {
+            return parsed;
+        }
+        if (parsed?.url && typeof parsed.url === "string") {
+            return parsed.url;
+        }
+        throw new Error("Unexpected attachment response payload");
+    }
+    catch (error) {
+        throw new Error(`Unable to parse attachment response: ${String(error)}`);
+    }
+}
+async function devinCreateSession(apiKey, body) {
+    const response = await fetch("https://api.devin.ai/v1/sessions", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    });
+    const text = await response.text();
+    ensureOk(response, text, "Create session");
+    return JSON.parse(text);
+}
+async function devinGetSession(apiKey, sessionId) {
+    const response = await fetch(`https://api.devin.ai/v1/sessions/${sessionId}`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`
+        }
+    });
+    const text = await response.text();
+    ensureOk(response, text, "Get session");
+    return JSON.parse(text);
+}
+async function devinListSessions(apiKey, params = {}) {
+    const url = new URL("https://api.devin.ai/v1/sessions");
+    if (params.limit) {
+        url.searchParams.set("limit", String(params.limit));
+    }
+    if (params.tag) {
+        url.searchParams.set("tag", params.tag);
+    }
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`
+        }
+    });
+    const text = await response.text();
+    ensureOk(response, text, "List sessions");
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.sessions)) {
+        return parsed.sessions;
+    }
+    return [];
+}
+async function pollUntilTerminal(apiKey, sessionId, timeoutMs = 30 * 60_000) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const session = await devinGetSession(apiKey, sessionId);
+        const status = String(session.status_enum ?? session.status ?? "UNKNOWN").toLowerCase();
+        if (["finished", "blocked", "error", "cancelled", "done", "complete"].includes(status)) {
+            return session;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+    throw new Error(`Session polling timed out for ${sessionId}`);
+}

package/dist/src/evidence/bundle.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEvidenceBundle = buildEvidenceBundle;
+exports.writeMetrics = writeMetrics;
+const node_path_1 = __importDefault(require("node:path"));
+const exec_1 = require("../utils/exec");
+const fs_1 = require("../utils/fs");
+function toSafeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function resolveEvidencePath(filePath) {
+    if (node_path_1.default.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return node_path_1.default.resolve(filePath);
+}
+async function buildEvidenceBundle(input) {
+    const root = node_path_1.default.resolve(input.evidenceRoot);
+    const area = toSafeName(input.item.docArea);
+    const bundleDir = node_path_1.default.join(root, area);
+    const evidenceDir = node_path_1.default.join(bundleDir, "evidence");
+    const docsDir = node_path_1.default.join(bundleDir, "impacted_docs");
+    (0, fs_1.ensureDir)(evidenceDir);
+    (0, fs_1.ensureDir)(docsDir);
+    const copiedEvidence = [];
+    for (const signal of input.item.signals) {
+        for (const evidencePath of signal.evidence) {
+            const src = resolveEvidencePath(evidencePath);
+            const fileName = toSafeName(node_path_1.default.basename(src));
+            const dest = node_path_1.default.join(evidenceDir, fileName);
+            if ((0, fs_1.copyIfExists)(src, dest)) {
+                copiedEvidence.push(node_path_1.default.relative(bundleDir, dest));
+            }
+        }
+    }
+    const copiedDocs = [];
+    for (const docPath of input.item.impactedDocs) {
+        const src = node_path_1.default.resolve(docPath);
+        const dest = node_path_1.default.join(docsDir, toSafeName(docPath));
+        if ((0, fs_1.copyIfExists)(src, dest)) {
+            copiedDocs.push(node_path_1.default.relative(bundleDir, dest));
+        }
+    }
+    const manifestPath = node_path_1.default.join(bundleDir, "manifest.json");
+    (0, fs_1.writeJsonFile)(manifestPath, {
+        run: {
+            runId: input.runInfo.runId,
+            repo: input.runInfo.repo,
+            baseSha: input.runInfo.baseSha,
+            headSha: input.runInfo.headSha,
+            trigger: input.runInfo.trigger,
+            timestamp: input.runInfo.timestamp
+        },
+        docArea: input.item.docArea,
+        mode: input.item.mode,
+        summary: input.item.summary,
+        signals: input.item.signals,
+        impactedDocs: input.item.impactedDocs,
+        copiedEvidence,
+        copiedDocs
+    });
+    const archivePath = `${bundleDir}.tar.gz`;
+    const parent = node_path_1.default.dirname(bundleDir);
+    const name = node_path_1.default.basename(bundleDir);
+    const tarResult = await (0, exec_1.execCommand)(`tar -czf ${JSON.stringify(archivePath)} -C ${JSON.stringify(parent)} ${JSON.stringify(name)}`);
+    if (tarResult.exitCode !== 0) {
+        throw new Error(`Failed to create evidence archive: ${tarResult.stderr || tarResult.stdout}`);
+    }
+    return {
+        bundleDir,
+        archivePath,
+        manifestPath,
+        attachmentPaths: [archivePath, manifestPath]
+    };
+}
+function writeMetrics(metrics) {
+    (0, fs_1.writeJsonFile)(node_path_1.default.resolve(".docdrift", "metrics.json"), metrics);
+}

package/dist/src/github/client.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postCommitComment = postCommitComment;
+exports.createIssue = createIssue;
+exports.renderRunComment = renderRunComment;
+exports.renderBlockedIssueBody = renderBlockedIssueBody;
+const rest_1 = require("@octokit/rest");
+function parseRepo(full) {
+    const [owner, repo] = full.split("/");
+    if (!owner || !repo) {
+        throw new Error(`Invalid repository slug: ${full}`);
+    }
+    return { owner, repo };
+}
+async function postCommitComment(input) {
+    const octokit = new rest_1.Octokit({ auth: input.token });
+    const { owner, repo } = parseRepo(input.repository);
+    const response = await octokit.repos.createCommitComment({
+        owner,
+        repo,
+        commit_sha: input.commitSha,
+        body: input.body
+    });
+    return response.data.html_url;
+}
+async function createIssue(input) {
+    const octokit = new rest_1.Octokit({ auth: input.token });
+    const { owner, repo } = parseRepo(input.repository);
+    const response = await octokit.issues.create({
+        owner,
+        repo,
+        title: input.issue.title,
+        body: input.issue.body,
+        labels: input.issue.labels
+    });
+    return response.data.html_url;
+}
+function renderRunComment(input) {
+    const lines = [];
+    lines.push(`## Doc Drift Result: ${input.docArea}`);
+    lines.push("");
+    lines.push(`- Decision: ${input.decision}`);
+    lines.push(`- Outcome: ${input.outcome}`);
+    lines.push(`- Summary: ${input.summary}`);
+    if (input.sessionUrl) {
+        lines.push(`- Devin Session: ${input.sessionUrl}`);
+    }
+    if (input.prUrl) {
+        lines.push(`- PR: ${input.prUrl}`);
+    }
+    if (input.issueUrl) {
+        lines.push(`- Issue: ${input.issueUrl}`);
+    }
+    if (input.validation.length) {
+        lines.push("");
+        lines.push("### Validation");
+        for (const row of input.validation) {
+            lines.push(`- \`${row.command}\`: ${row.result}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderBlockedIssueBody(input) {
+    const lines = [];
+    lines.push(`Doc area: ${input.docArea}`);
+    lines.push("");
+    lines.push("## Evidence");
+    lines.push(input.evidenceSummary);
+    lines.push("");
+    lines.push("## Questions");
+    for (const question of input.questions) {
+        lines.push(`- ${question}`);
+    }
+    if (input.suggestedPatch) {
+        lines.push("");
+        lines.push("## Suggested Patch");
+        lines.push("```diff");
+        lines.push(input.suggestedPatch);
+        lines.push("```");
+    }
+    if (input.sessionUrl) {
+        lines.push("");
+        lines.push(`Session: ${input.sessionUrl}`);
+    }
+    return lines.join("\n");
+}