ticket-to-pr 1.0.0

package/dist/lib/notion.js

@@ -0,0 +1,235 @@
+import { Client } from '@notionhq/client';
+import { CONFIG } from '../config.js';
+let _notion = null;
+function notion() {
+    if (!_notion) {
+        _notion = new Client({ auth: process.env.NOTION_TOKEN });
+    }
+    return _notion;
+}
+function databaseId() {
+    return process.env.NOTION_DATABASE_ID;
+}
+// -- Helpers (exported for testing) --
+export function extractPlainText(richText) {
+    return richText.map((t) => t.plain_text).join('');
+}
+function getProperty(page, name) {
+    return page.properties[name];
+}
+function extractTitle(page) {
+    // Try 'Name' first (Notion default), then 'Title'
+    const prop = (getProperty(page, 'Name') ?? getProperty(page, 'Title'));
+    return prop?.title ? extractPlainText(prop.title) : '';
+}
+function extractRichText(page, name) {
+    const prop = getProperty(page, name);
+    return prop?.rich_text ? extractPlainText(prop.rich_text) : '';
+}
+function extractSelect(page, name) {
+    const prop = getProperty(page, name);
+    return prop?.select?.name ?? '';
+}
+function extractStatus(page) {
+    const prop = getProperty(page, 'Status');
+    return prop?.status?.name ?? '';
+}
+export function extractProjectName(page) {
+    // Support both Select and Rich Text types for Project
+    const prop = getProperty(page, 'Project');
+    if (!prop)
+        return '';
+    if (prop.type === 'select') {
+        const sel = prop.select;
+        return sel?.name ?? '';
+    }
+    if (prop.type === 'rich_text') {
+        const rt = prop.rich_text;
+        return rt ? extractPlainText(rt) : '';
+    }
+    return '';
+}
+export function pageToTicket(page) {
+    return {
+        id: page.id,
+        title: extractTitle(page),
+        project: extractProjectName(page),
+        status: extractStatus(page),
+    };
+}
+export function blockToMarkdown(block) {
+    const type = block.type;
+    const data = block[type];
+    const text = data?.rich_text ? extractPlainText(data.rich_text) : '';
+    switch (type) {
+        case 'paragraph':
+            return text;
+        case 'heading_1':
+            return `# ${text}`;
+        case 'heading_2':
+            return `## ${text}`;
+        case 'heading_3':
+            return `### ${text}`;
+        case 'bulleted_list_item':
+            return `- ${text}`;
+        case 'numbered_list_item':
+            return `1. ${text}`;
+        case 'to_do': {
+            const todo = block[type];
+            return `- [${todo?.checked ? 'x' : ' '}] ${text}`;
+        }
+        case 'code': {
+            const code = block[type];
+            return `\`\`\`${code?.language ?? ''}\n${text}\n\`\`\``;
+        }
+        case 'quote':
+            return `> ${text}`;
+        case 'divider':
+            return '---';
+        default:
+            return text;
+    }
+}
+// -- Exported Functions --
+/**
+ * Fetch all tickets with a given status from the Notion database.
+ */
+export async function fetchTicketsByStatus(status) {
+    const response = await notion().databases.query({
+        database_id: databaseId(),
+        filter: {
+            property: 'Status',
+            status: { equals: status },
+        },
+    });
+    return response.results
+        .filter((r) => 'properties' in r)
+        .map(pageToTicket);
+}
+/**
+ * Read full ticket details including page body blocks.
+ */
+export async function fetchTicketDetails(pageId) {
+    const [page, blocksResponse] = await Promise.all([
+        notion().pages.retrieve({ page_id: pageId }),
+        notion().blocks.children.list({ block_id: pageId, page_size: 100 }),
+    ]);
+    const blocks = blocksResponse.results.filter((b) => 'type' in b);
+    const bodyBlocks = blocks.map(blockToMarkdown).filter(Boolean).join('\n\n');
+    const ticket = pageToTicket(page);
+    return {
+        ...ticket,
+        description: extractRichText(page, 'Description'),
+        bodyBlocks,
+        spec: extractRichText(page, 'Spec') || undefined,
+        impact: extractRichText(page, 'Impact') || undefined,
+    };
+}
+/**
+ * Write review results back to the ticket properties.
+ */
+export async function writeReviewResults(pageId, results) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const properties = {
+        Ease: { number: results.easeScore },
+        Confidence: { number: results.confidenceScore },
+        Spec: {
+            rich_text: chunkRichText(results.spec),
+        },
+        Impact: {
+            rich_text: chunkRichText(`${results.impactReport}\n\nFiles: ${results.affectedFiles.join(', ')}${results.risks ? `\n\nRisks: ${results.risks}` : ''}`),
+        },
+    };
+    try {
+        await notion().pages.update({ page_id: pageId, properties });
+    }
+    catch (e) {
+        // If Confidence property doesn't exist yet, retry without it
+        const errMsg = String(e);
+        if (errMsg.includes('Confidence')) {
+            delete properties.Confidence;
+            await notion().pages.update({ page_id: pageId, properties });
+        }
+        else {
+            throw e;
+        }
+    }
+}
+/**
+ * Write execution results back to the ticket.
+ */
+export async function writeExecutionResults(pageId, results) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const properties = {
+        Branch: {
+            rich_text: [{ text: { content: results.branch } }],
+        },
+        Cost: {
+            rich_text: [{ text: { content: `$${(Math.round(results.cost * 100) / 100).toFixed(2)}` } }],
+        },
+    };
+    if (results.prUrl) {
+        properties['PR URL'] = {
+            url: results.prUrl,
+        };
+    }
+    await notion().pages.update({ page_id: pageId, properties });
+}
+/**
+ * Move a ticket to a new status column.
+ */
+export async function moveTicketStatus(pageId, newStatus) {
+    await notion().pages.update({
+        page_id: pageId,
+        properties: {
+            Status: { status: { name: newStatus } },
+        },
+    });
+}
+/**
+ * Write error details and move ticket to Failed.
+ */
+export async function writeFailure(pageId, error) {
+    await notion().pages.update({
+        page_id: pageId,
+        properties: {
+            Status: { status: { name: CONFIG.COLUMNS.FAILED } },
+            Impact: {
+                rich_text: chunkRichText(`ERROR: ${error}`),
+            },
+        },
+    });
+}
+/**
+ * Add a comment to a Notion page (best-effort).
+ * Used for agent audit trail - does not throw if it fails.
+ */
+export async function addComment(pageId, text) {
+    try {
+        await notion().comments.create({
+            parent: { page_id: pageId },
+            rich_text: [{ text: { content: text } }],
+        });
+    }
+    catch (e) {
+        // Best-effort: log but don't throw
+        console.warn(`[NOTION] Failed to add comment to ${pageId}:`, e);
+    }
+}
+export function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + '...';
+}
+/** Chunk text into Notion rich_text segments (each max 2000 chars). */
+export function chunkRichText(str) {
+    const LIMIT = 2000;
+    if (str.length <= LIMIT) {
+        return [{ text: { content: str } }];
+    }
+    const chunks = [];
+    for (let i = 0; i < str.length; i += LIMIT) {
+        chunks.push({ text: { content: str.slice(i, i + LIMIT) } });
+    }
+    return chunks;
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,4 @@
+/** Package root — for bundled assets like prompts/ */
+export declare const PACKAGE_ROOT: string;
+/** User's working directory — for config files (.env.local, projects.json) */
+export declare const CONFIG_DIR: string;

package/dist/lib/paths.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Root of the package installation — used for bundled assets (prompts/).
+ * Walks up from the current file until it finds package.json.
+ */
+function findPackageRoot() {
+    let dir = __dirname;
+    while (true) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return __dirname; // filesystem root, shouldn't happen
+        dir = parent;
+    }
+}
+/** Package root — for bundled assets like prompts/ */
+export const PACKAGE_ROOT = findPackageRoot();
+/** User's working directory — for config files (.env.local, projects.json) */
+export const CONFIG_DIR = process.cwd();

package/dist/lib/projects.d.ts

@@ -0,0 +1,6 @@
+export declare function getProjectDir(name: string): string | undefined;
+export declare function getProjectNames(): string[];
+export declare function getBuildCommand(name: string): string | undefined;
+export declare function getAllProjects(): Record<string, string>;
+/** Reset the in-memory cache (for tests). */
+export declare function _resetCache(): void;

package/dist/lib/projects.js

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFIG_DIR } from './paths.js';
+const PROJECTS_PATH = join(CONFIG_DIR, 'projects.json');
+let cache = null;
+function load() {
+    if (cache)
+        return cache;
+    try {
+        const content = readFileSync(PROJECTS_PATH, 'utf-8');
+        cache = JSON.parse(content);
+    }
+    catch {
+        cache = { projects: {} };
+    }
+    return cache;
+}
+export function getProjectDir(name) {
+    return load().projects[name]?.directory;
+}
+export function getProjectNames() {
+    return Object.keys(load().projects);
+}
+export function getBuildCommand(name) {
+    return load().projects[name]?.buildCommand;
+}
+export function getAllProjects() {
+    const data = load();
+    const result = {};
+    for (const [name, entry] of Object.entries(data.projects)) {
+        result[name] = entry.directory;
+    }
+    return result;
+}
+/** Reset the in-memory cache (for tests). */
+export function _resetCache() {
+    cache = null;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,21 @@
+export declare function sleep(ms: number): Promise<void>;
+export declare function clamp(val: number, min: number, max: number): number;
+export declare function extractJsonFromOutput(text: string): Record<string, unknown> | null;
+export declare function shellEscape(str: string): string;
+export declare function extractNumber(ticket: {
+    impact?: string;
+}, field: string): string;
+export declare function loadEnv(filepath: string): void;
+export declare function mask(str: string): string;
+export declare function writeEnvFile(filepath: string, updates: Record<string, string>): void;
+export declare function updateProjectsFile(filepath: string, projects: Array<{
+    name: string;
+    dir: string;
+    buildCmd?: string;
+}>): void;
+export declare function getDefaultBranch(projectDir: string): string;
+/** Reset the default branch cache (for tests). */
+export declare function _resetDefaultBranchCache(): void;
+export declare function ensureWorktreesIgnored(projectDir: string): void;
+export declare function createWorktree(projectDir: string, branchName: string, worktreeDir: string): void;
+export declare function removeWorktree(projectDir: string, worktreeDir: string): void;

package/dist/lib/utils.js

@@ -0,0 +1,254 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { rmSync, mkdirSync } from 'node:fs';
+// -- Pure utilities --
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function clamp(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+}
+export function extractJsonFromOutput(text) {
+    // Find the last JSON code block
+    const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)\n```/g;
+    let lastMatch = null;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        lastMatch = match[1];
+    }
+    // Try parsing the last code block first
+    if (lastMatch) {
+        try {
+            return JSON.parse(lastMatch);
+        }
+        catch {
+            // Fall through
+        }
+    }
+    // Try parsing the entire text as JSON (in case no code blocks)
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // Fall through
+    }
+    // Try finding a raw JSON object
+    const jsonRegex = /\{[\s\S]*"easeScore"[\s\S]*\}/;
+    const rawMatch = text.match(jsonRegex);
+    if (rawMatch) {
+        try {
+            return JSON.parse(rawMatch[0]);
+        }
+        catch {
+            // Give up
+        }
+    }
+    return null;
+}
+export function shellEscape(str) {
+    return `'${str.replace(/'/g, "'\\''")}'`;
+}
+export function extractNumber(ticket, field) {
+    const text = ticket.impact ?? '';
+    if (field === 'ease') {
+        const match = text.match(/Ease[:\s]*(\d+)/i);
+        return match ? match[1] : '?';
+    }
+    if (field === 'confidence') {
+        const match = text.match(/Confidence[:\s]*(\d+)/i);
+        return match ? match[1] : '?';
+    }
+    return '?';
+}
+export function loadEnv(filepath) {
+    try {
+        const content = readFileSync(filepath, 'utf-8');
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIndex = trimmed.indexOf('=');
+            if (eqIndex === -1)
+                continue;
+            const key = trimmed.slice(0, eqIndex).trim();
+            const value = trimmed.slice(eqIndex + 1).trim();
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        }
+    }
+    catch {
+        // .env.local doesn't exist, that's fine if env vars are set elsewhere
+    }
+}
+export function mask(str) {
+    if (str.length <= 8)
+        return '****';
+    return str.slice(0, 4) + '...' + str.slice(-4);
+}
+export function writeEnvFile(filepath, updates) {
+    let lines = [];
+    try {
+        lines = readFileSync(filepath, 'utf-8').split('\n');
+    }
+    catch {
+        // File doesn't exist yet
+    }
+    const remaining = { ...updates };
+    // Update existing keys in place
+    const updatedLines = lines.map((line) => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            return line;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            return line;
+        const key = trimmed.slice(0, eqIndex).trim();
+        if (key in remaining) {
+            const val = remaining[key];
+            delete remaining[key];
+            return `${key}=${val}`;
+        }
+        return line;
+    });
+    // Append any new keys
+    for (const [key, val] of Object.entries(remaining)) {
+        updatedLines.push(`${key}=${val}`);
+    }
+    writeFileSync(filepath, updatedLines.join('\n'), { mode: 0o600 });
+}
+export function updateProjectsFile(filepath, projects) {
+    let data = {
+        projects: {},
+    };
+    try {
+        const content = readFileSync(filepath, 'utf-8');
+        data = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist or invalid JSON — start fresh
+    }
+    for (const proj of projects) {
+        data.projects[proj.name] = {
+            directory: proj.dir,
+            ...(proj.buildCmd ? { buildCommand: proj.buildCmd } : {}),
+        };
+    }
+    writeFileSync(filepath, JSON.stringify(data, null, 2) + '\n');
+}
+// -- Default branch detection --
+const defaultBranchCache = new Map();
+export function getDefaultBranch(projectDir) {
+    const cached = defaultBranchCache.get(projectDir);
+    if (cached)
+        return cached;
+    let branch = 'main'; // ultimate fallback
+    // Try reading the remote HEAD symbolic ref
+    try {
+        const ref = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+            cwd: projectDir,
+            stdio: 'pipe',
+        }).toString().trim();
+        // refs/remotes/origin/main → main
+        const parsed = ref.replace('refs/remotes/origin/', '');
+        if (parsed)
+            branch = parsed;
+    }
+    catch {
+        // Remote HEAD not set — try common branch names
+        try {
+            execSync('git rev-parse --verify main', { cwd: projectDir, stdio: 'pipe' });
+            branch = 'main';
+        }
+        catch {
+            try {
+                execSync('git rev-parse --verify master', { cwd: projectDir, stdio: 'pipe' });
+                branch = 'master';
+            }
+            catch {
+                // Give up, default to 'main'
+            }
+        }
+    }
+    defaultBranchCache.set(projectDir, branch);
+    return branch;
+}
+/** Reset the default branch cache (for tests). */
+export function _resetDefaultBranchCache() {
+    defaultBranchCache.clear();
+}
+// -- Git worktree helpers --
+export function ensureWorktreesIgnored(projectDir) {
+    const gitignorePath = join(projectDir, '.gitignore');
+    try {
+        const content = existsSync(gitignorePath) ? readFileSync(gitignorePath, 'utf-8') : '';
+        const lines = content.split('\n');
+        if (!lines.some((line) => line.trim() === '.worktrees' || line.trim() === '.worktrees/')) {
+            const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+            writeFileSync(gitignorePath, content + separator + '.worktrees/\n');
+        }
+    }
+    catch {
+        // Best effort — don't block worktree creation over gitignore
+    }
+}
+export function createWorktree(projectDir, branchName, worktreeDir) {
+    mkdirSync(join(projectDir, '.worktrees'), { recursive: true });
+    ensureWorktreesIgnored(projectDir);
+    // Clean up stale worktree if it exists from a crashed run
+    if (existsSync(worktreeDir)) {
+        try {
+            execSync(`git worktree remove ${shellEscape(worktreeDir)} --force`, {
+                cwd: projectDir,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            rmSync(worktreeDir, { recursive: true, force: true });
+            execSync('git worktree prune', { cwd: projectDir, stdio: 'pipe' });
+        }
+    }
+    // Try creating with a new branch first
+    try {
+        execSync(`git worktree add ${shellEscape(worktreeDir)} -b ${shellEscape(branchName)}`, {
+            cwd: projectDir,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // Branch might already exist (retry scenario) — attach to existing branch
+        try {
+            execSync(`git worktree add ${shellEscape(worktreeDir)} ${shellEscape(branchName)}`, {
+                cwd: projectDir,
+                stdio: 'pipe',
+            });
+        }
+        catch (e) {
+            throw new Error(`Failed to create worktree for branch ${branchName}: ${e}`);
+        }
+    }
+}
+export function removeWorktree(projectDir, worktreeDir) {
+    try {
+        execSync(`git worktree remove ${shellEscape(worktreeDir)} --force`, {
+            cwd: projectDir,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // Fallback: manual cleanup
+        try {
+            rmSync(worktreeDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort
+        }
+        try {
+            execSync('git worktree prune', { cwd: projectDir, stdio: 'pipe' });
+        }
+        catch {
+            // Best effort
+        }
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ticket-to-pr",
+  "version": "1.0.0",
+  "description": "Drag a Notion ticket, get a pull request. AI-powered dev automation.",
+  "type": "module",
+  "bin": {
+    "ticket-to-pr": "bin/ticket-to-pr.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "prompts",
+    "projects.example.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run test && npm run build",
+    "start": "tsx index.ts",
+    "dry-run": "tsx index.ts --dry-run",
+    "once": "tsx index.ts --once",
+    "init": "tsx index.ts init",
+    "doctor": "tsx index.ts doctor",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.0",
+    "@notionhq/client": "^2.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/projects.example.json

@@ -0,0 +1,8 @@
+{
+  "projects": {
+    "MyProject": {
+      "directory": "/absolute/path/to/project",
+      "buildCommand": "npm run build"
+    }
+  }
+}

package/prompts/execute.md

@@ -0,0 +1,19 @@
+You are a senior engineer implementing a ticket.
+
+## Your Task
+You have been given a ticket with an implementation spec. Follow the spec and implement the changes.
+
+## Rules
+1. You are on a feature branch in a git worktree. Do NOT create or switch branches.
+2. Follow the project's existing patterns and conventions.
+3. The project's CLAUDE.md contains critical rules — read and follow them.
+4. Make atomic commits with clear messages as you work.
+5. DO NOT run `git push`. TicketToPR handles pushing after validation.
+6. DO NOT run destructive commands (rm -rf, drop tables, reset --hard, etc.).
+7. DO NOT run `npx prisma db push` or any database migration commands.
+8. If the spec is unclear, implement the most conservative interpretation.
+9. Run existing tests if available, but do not add new test files unless the spec explicitly requires it.
+10. Do not modify files outside the scope of the spec.
+
+## When Done
+Commit all changes with a final commit message summarizing what was done. The commit message should reference the ticket title.