@metmirr/prlen 0.1.0

package/README.md

@@ -0,0 +1,82 @@
+# prlen-cli
+
+Local TypeScript CLI for PR Lens.
+
+## Commands
+
+```bash
+npm install
+npm run build
+node dist/index.js --help
+```
+
+### Login
+
+```bash
+prlen login
+```
+
+Optional:
+- `PRLEN_BASE_URL=http://127.0.0.1:3000`
+
+`prlen login` now opens a browser approval page on your PR Lens site.
+If you're already signed in on the web app, just approve the request there — no GitHub token needed in the CLI.
+
+### Install Claude/Codex skill
+
+```bash
+prlen install-skill
+```
+
+Options:
+- `--target claude`
+- `--target codex`
+- `--target both`
+- `--force`
+- `--check`
+
+This installs the bundled PR Lens skill into:
+- Claude Code: `~/.claude/skills/prlen`
+- Codex: `~/.codex/skills/prlen`
+
+Check whether it is already installed:
+
+```bash
+prlen install-skill --check
+```
+
+Remove it again:
+
+```bash
+prlen uninstall-skill
+```
+
+### Who am I?
+
+```bash
+prlen whoami
+```
+
+### Post with your own prompt
+
+```bash
+prlen post 12 --prompt "Add API endpoints for CLI publishing" --yes
+```
+
+### Agent mode: pipe the drafted post through stdin
+
+```bash
+printf '%s' "Add API endpoints for CLI publishing with bearer auth, whoami, and a public prompt-template endpoint." \
+  | prlen post 12 --prompt-stdin --yes
+```
+
+`prlen post` also auto-reads piped stdin when `--prompt` is omitted:
+
+```bash
+printf '%s' "Add API endpoints for CLI publishing with bearer auth and PR metadata validation." \
+  | prlen post 12 --yes
+```
+
+Notes:
+- `post` currently supports manual prompt input first: `--prompt`, `--prompt-stdin`, or piped stdin.
+- Full LLM-provider generation is the next slice.

package/dist/commands/install-skill.js

@@ -0,0 +1,74 @@
+import { cp, rm } from 'node:fs/promises';
+import { ensureTargetRoot, getSkillStatus, normalizeTargets, packageSkillDir, } from '../lib/skills.js';
+import { printError, printMuted, printSuccess } from '../utils/ui.js';
+async function installTarget(target, force) {
+    const sourceDir = packageSkillDir();
+    const status = await getSkillStatus(target);
+    if (status.installed && !force) {
+        throw new Error(`${target} skill already exists at ${status.destination}. Re-run with --force to overwrite it.`);
+    }
+    await ensureTargetRoot(target);
+    if (status.installed) {
+        await rm(status.destination, { recursive: true, force: true });
+    }
+    await cp(sourceDir, status.destination, { recursive: true });
+    return {
+        target,
+        destination: status.destination,
+        action: status.installed ? 'updated' : 'installed',
+    };
+}
+async function checkTargets(target) {
+    let allInstalled = true;
+    for (const item of normalizeTargets(target)) {
+        const status = await getSkillStatus(item);
+        if (status.installed) {
+            printSuccess(`Installed for ${item} → ${status.destination}`);
+        }
+        else {
+            printMuted(`Missing for ${item} → ${status.destination}`);
+            allInstalled = false;
+        }
+    }
+    return allInstalled;
+}
+export function registerInstallSkillCommand(program) {
+    program
+        .command('install-skill')
+        .description('Install the PR Lens agent skill for Claude Code and/or Codex')
+        .option('--target <target>', 'claude, codex, or both', 'both')
+        .option('--force', 'Overwrite an existing installed skill')
+        .option('--check', 'Only check whether the skill is already installed')
+        .action(async (options) => {
+        const target = (options.target || 'both');
+        if (!['claude', 'codex', 'both'].includes(target)) {
+            printError('Invalid --target value. Use claude, codex, or both.');
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            if (options.check) {
+                const ok = await checkTargets(target);
+                process.exitCode = ok ? 0 : 1;
+                return;
+            }
+            const results = [];
+            for (const item of normalizeTargets(target)) {
+                results.push(await installTarget(item, Boolean(options.force)));
+            }
+            for (const result of results) {
+                printSuccess(`${result.action === 'updated' ? 'Updated' : 'Installed'} ${result.target} skill → ${result.destination}`);
+            }
+            if (results.some((result) => result.target === 'claude')) {
+                printMuted('Claude Code loads user skills from ~/.claude/skills and usually hot-reloads them.');
+            }
+            if (results.some((result) => result.target === 'codex')) {
+                printMuted('Restart Codex to pick up the new skill.');
+            }
+        }
+        catch (error) {
+            printError(error instanceof Error ? error.message : 'Failed to install skill');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/login.js

@@ -0,0 +1,120 @@
+import { spawn } from 'node:child_process';
+import ora from 'ora';
+import { ApiError, exchangeGithubToken, getDefaultBaseUrl, pollCliLogin, startCliLogin, } from '../lib/api.js';
+import { getStoredBaseUrl, saveAuth } from '../lib/auth.js';
+import { printError, printMuted, printSuccess } from '../utils/ui.js';
+class LoginCancelledError extends Error {
+    constructor() {
+        super('Login cancelled');
+        this.name = 'LoginCancelledError';
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function openBrowser(url) {
+    try {
+        const child = process.platform === 'darwin'
+            ? spawn('open', [url], { detached: true, stdio: 'ignore' })
+            : process.platform === 'win32'
+                ? spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' })
+                : spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loginWithBrowser(baseUrl) {
+    const start = await startCliLogin(baseUrl);
+    console.log(`Confirmation code: ${start.code}`);
+    console.log('Open this URL in your browser:');
+    console.log(`  ${start.verification_url}`);
+    console.log('');
+    if (openBrowser(start.verification_url)) {
+        printMuted('Opened browser for approval');
+    }
+    else {
+        printMuted('Could not open a browser automatically; open the URL above');
+    }
+    const spinner = ora(`Waiting for approval (${start.code})...`).start();
+    let cancelled = false;
+    const handleSignal = () => {
+        cancelled = true;
+        spinner.stop();
+        printMuted('Cancelled');
+    };
+    process.once('SIGINT', handleSignal);
+    process.once('SIGTERM', handleSignal);
+    try {
+        while (true) {
+            if (cancelled) {
+                throw new LoginCancelledError();
+            }
+            const poll = await pollCliLogin(baseUrl, start.challenge_id, start.poll_token);
+            if (poll.status === 'approved') {
+                spinner.stop();
+                await saveAuth({
+                    sessionToken: poll.session_token,
+                    username: poll.username,
+                    baseUrl,
+                });
+                printSuccess(`Logged in as @${poll.username}`);
+                printMuted(`Session expires: ${poll.expires_at}`);
+                return;
+            }
+            await sleep(start.interval_seconds * 1000);
+        }
+    }
+    catch (error) {
+        if (error instanceof LoginCancelledError) {
+            throw error;
+        }
+        spinner.fail('CLI login failed');
+        throw error;
+    }
+    finally {
+        process.removeListener('SIGINT', handleSignal);
+        process.removeListener('SIGTERM', handleSignal);
+    }
+}
+export function registerLoginCommand(program) {
+    program
+        .command('login')
+        .description('Authenticate by approving this CLI in your PR Lens browser session')
+        .option('--base-url <url>', 'PR Lens API base URL')
+        .option('--github-token <token>', 'Advanced fallback: exchange an existing GitHub token for a PR Lens session')
+        .action(async (options) => {
+        try {
+            const storedBaseUrl = await getStoredBaseUrl();
+            const baseUrl = getDefaultBaseUrl(options.baseUrl || storedBaseUrl);
+            if (options.githubToken) {
+                const session = await exchangeGithubToken(baseUrl, options.githubToken);
+                await saveAuth({
+                    githubToken: options.githubToken,
+                    sessionToken: session.session_token,
+                    username: session.username,
+                    baseUrl,
+                });
+                printSuccess(`Logged in as @${session.username}`);
+                printMuted(`Session expires: ${session.expires_at}`);
+                return;
+            }
+            await loginWithBrowser(baseUrl);
+        }
+        catch (error) {
+            if (error instanceof LoginCancelledError) {
+                process.exitCode = 130;
+                return;
+            }
+            if (error instanceof ApiError) {
+                printError(`${error.message} (${error.status})`);
+                process.exitCode = 1;
+                return;
+            }
+            printError(error instanceof Error ? error.message : 'Unknown error');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/logout.js

@@ -0,0 +1,11 @@
+import { clearAuth } from '../lib/auth.js';
+import { printSuccess } from '../utils/ui.js';
+export function registerLogoutCommand(program) {
+    program
+        .command('logout')
+        .description('Clear stored PR Lens credentials')
+        .action(async () => {
+        await clearAuth();
+        printSuccess('Logged out');
+    });
+}

package/dist/commands/post.js

@@ -0,0 +1,82 @@
+import ora from 'ora';
+import { ApiError, createPost, getDefaultBaseUrl, getPullRequestMetadata } from '../lib/api.js';
+import { getStoredBaseUrl, getStoredSessionToken } from '../lib/auth.js';
+import { resolvePullRequestReference } from '../lib/github.js';
+import { confirm, printError, printMuted, printPreviewBox, printSuccess } from '../utils/ui.js';
+async function readPromptFromStdin() {
+    if (process.stdin.isTTY) {
+        return undefined;
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    return text || undefined;
+}
+export function registerPostCommand(program) {
+    program
+        .command('post <pr-ref>')
+        .description('Publish a PR Lens post from a GitHub PR')
+        .option('--prompt <text>', 'Use your own prompt text instead of generating one')
+        .option('--prompt-stdin', 'Read the prompt text from stdin (useful for agents)')
+        .option('--model <model>', 'Record the model that generated the prompt')
+        .option('--yes', 'Skip confirmation')
+        .option('--base-url <url>', 'PR Lens API base URL')
+        .action(async (prRef, options) => {
+        try {
+            const storedBaseUrl = await getStoredBaseUrl();
+            const baseUrl = getDefaultBaseUrl(options.baseUrl || storedBaseUrl);
+            const sessionToken = await getStoredSessionToken();
+            if (!sessionToken) {
+                throw new Error('Not logged in. Run `prlen login` first.');
+            }
+            const stdinPrompt = options.promptStdin ? await readPromptFromStdin() : undefined;
+            const autoStdinPrompt = !options.prompt && !options.promptStdin ? await readPromptFromStdin() : undefined;
+            const prompt = options.prompt?.trim() || stdinPrompt || autoStdinPrompt;
+            if (!prompt) {
+                throw new Error('Provide prompt text with `--prompt`, `--prompt-stdin`, or piped stdin. LLM generation is next.');
+            }
+            const resolveSpinner = ora('Resolving pull request...').start();
+            const pr = await resolvePullRequestReference(prRef);
+            resolveSpinner.succeed(`Resolved ${pr.repoFullName}#${pr.prNumber}`);
+            const metadataSpinner = ora('Fetching PR metadata from PR Lens...').start();
+            const metadata = await getPullRequestMetadata(baseUrl, sessionToken, pr.repoFullName, pr.prNumber);
+            metadataSpinner.stop();
+            console.log('Preview:');
+            printPreviewBox(prompt);
+            printMuted(`PR: ${metadata.repo_full_name}#${metadata.pr_number} — ${metadata.pr_title}`);
+            if (!options.yes) {
+                const ok = await confirm('Post this? [Y/n]');
+                if (!ok) {
+                    printMuted('Cancelled');
+                    return;
+                }
+            }
+            const publishSpinner = ora('Publishing to PR Lens...').start();
+            const response = await createPost(baseUrl, sessionToken, {
+                pr_url: metadata.pr_url,
+                pr_number: metadata.pr_number,
+                pr_title: metadata.pr_title,
+                repo_full_name: metadata.repo_full_name,
+                prompt,
+                languages: metadata.languages,
+                files_changed: metadata.files_changed,
+                additions: metadata.additions,
+                deletions: metadata.deletions,
+                model_used: options.model,
+            });
+            publishSpinner.stop();
+            printSuccess(`Published → ${response.url}`);
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                printError(`${error.message} (${error.status})`);
+                process.exitCode = 1;
+                return;
+            }
+            printError(error instanceof Error ? error.message : 'Unknown error');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/uninstall-skill.js

@@ -0,0 +1,34 @@
+import { printError, printMuted, printSuccess } from '../utils/ui.js';
+import { normalizeTargets, removeInstalledSkill, targetDir } from '../lib/skills.js';
+export function registerUninstallSkillCommand(program) {
+    program
+        .command('uninstall-skill')
+        .description('Remove the PR Lens agent skill from Claude Code and/or Codex')
+        .option('--target <target>', 'claude, codex, or both', 'both')
+        .action(async (options) => {
+        const target = (options.target || 'both');
+        if (!['claude', 'codex', 'both'].includes(target)) {
+            printError('Invalid --target value. Use claude, codex, or both.');
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            for (const item of normalizeTargets(target)) {
+                const removed = await removeInstalledSkill(item);
+                if (removed) {
+                    printSuccess(`Removed ${item} skill → ${targetDir(item)}`);
+                }
+                else {
+                    printMuted(`${item} skill was not installed → ${targetDir(item)}`);
+                }
+            }
+            if (target === 'codex' || target === 'both') {
+                printMuted('Restart Codex if it is currently running.');
+            }
+        }
+        catch (error) {
+            printError(error instanceof Error ? error.message : 'Failed to uninstall skill');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/whoami.js

@@ -0,0 +1,30 @@
+import { ApiError, getDefaultBaseUrl, getWhoAmI } from '../lib/api.js';
+import { getStoredBaseUrl, getStoredSessionToken } from '../lib/auth.js';
+import { printError } from '../utils/ui.js';
+export function registerWhoamiCommand(program) {
+    program
+        .command('whoami')
+        .description('Show the authenticated PR Lens user')
+        .option('--base-url <url>', 'PR Lens API base URL')
+        .action(async (options) => {
+        try {
+            const storedBaseUrl = await getStoredBaseUrl();
+            const baseUrl = getDefaultBaseUrl(options.baseUrl || storedBaseUrl);
+            const sessionToken = await getStoredSessionToken();
+            if (!sessionToken) {
+                throw new Error('Not logged in. Run `prlen login` first.');
+            }
+            const whoami = await getWhoAmI(baseUrl, sessionToken);
+            console.log(`@${whoami.username} — ${whoami.connected_repos} connected repos, ${whoami.posts_today} posts today`);
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                printError(`${error.message} (${error.status})`);
+                process.exitCode = 1;
+                return;
+            }
+            printError(error instanceof Error ? error.message : 'Unknown error');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerInstallSkillCommand } from './commands/install-skill.js';
+import { registerLoginCommand } from './commands/login.js';
+import { registerLogoutCommand } from './commands/logout.js';
+import { registerPostCommand } from './commands/post.js';
+import { registerUninstallSkillCommand } from './commands/uninstall-skill.js';
+import { registerWhoamiCommand } from './commands/whoami.js';
+const program = new Command();
+program
+    .name('prlen')
+    .description('Publish pull requests to PR Lens from your terminal or coding agent')
+    .version('0.1.0');
+registerLoginCommand(program);
+registerWhoamiCommand(program);
+registerLogoutCommand(program);
+registerPostCommand(program);
+registerInstallSkillCommand(program);
+registerUninstallSkillCommand(program);
+program.parseAsync(process.argv);

package/dist/lib/api.js

@@ -0,0 +1,75 @@
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.code = code;
+    }
+}
+export function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/$/, '');
+}
+async function request(baseUrl, pathname, init = {}, sessionToken) {
+    const headers = new Headers(init.headers);
+    headers.set('Accept', 'application/json');
+    if (init.body && !headers.has('Content-Type')) {
+        headers.set('Content-Type', 'application/json');
+    }
+    if (sessionToken) {
+        headers.set('Authorization', `Bearer ${sessionToken}`);
+    }
+    const response = await fetch(`${normalizeBaseUrl(baseUrl)}${pathname}`, {
+        ...init,
+        headers,
+    });
+    const text = await response.text();
+    const payload = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+        throw new ApiError(payload.error || `Request failed with ${response.status}`, response.status, payload.code);
+    }
+    return payload;
+}
+export function getDefaultBaseUrl(storedBaseUrl) {
+    return process.env.PRLEN_BASE_URL || storedBaseUrl || 'https://prlen.dev';
+}
+export async function getClientConfig(baseUrl) {
+    return request(baseUrl, '/api/v1/client-config');
+}
+export async function startCliLogin(baseUrl) {
+    return request(baseUrl, '/api/v1/auth/cli/start', {
+        method: 'POST',
+    });
+}
+export async function pollCliLogin(baseUrl, challengeId, pollToken) {
+    return request(baseUrl, '/api/v1/auth/cli/poll', {
+        method: 'POST',
+        body: JSON.stringify({
+            challenge_id: challengeId,
+            poll_token: pollToken,
+        }),
+    });
+}
+export async function exchangeGithubToken(baseUrl, githubToken) {
+    return request(baseUrl, '/api/v1/auth/github', {
+        method: 'POST',
+        body: JSON.stringify({ github_token: githubToken }),
+    });
+}
+export async function getWhoAmI(baseUrl, sessionToken) {
+    return request(baseUrl, '/api/v1/whoami', {}, sessionToken);
+}
+export async function getPullRequestMetadata(baseUrl, sessionToken, repoFullName, prNumber) {
+    const params = new URLSearchParams({
+        repo_full_name: repoFullName,
+        pr_number: String(prNumber),
+    });
+    return request(baseUrl, `/api/v1/pr-metadata?${params.toString()}`, {}, sessionToken);
+}
+export async function createPost(baseUrl, sessionToken, payload) {
+    return request(baseUrl, '/api/v1/posts', {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    }, sessionToken);
+}

package/dist/lib/auth.js

@@ -0,0 +1,47 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+function configDir() {
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    return xdgConfigHome ? path.join(xdgConfigHome, 'prlen') : path.join(homedir(), '.config', 'prlen');
+}
+export function getAuthFilePath() {
+    return path.join(configDir(), 'auth.json');
+}
+export async function loadAuth() {
+    try {
+        const raw = await readFile(getAuthFilePath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        return {};
+    }
+}
+export async function saveAuth(state) {
+    await mkdir(configDir(), { recursive: true });
+    await writeFile(getAuthFilePath(), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+export async function clearAuth() {
+    await rm(getAuthFilePath(), { force: true });
+}
+export async function getStoredSessionToken() {
+    if (process.env.PRLEN_TOKEN) {
+        return process.env.PRLEN_TOKEN;
+    }
+    const auth = await loadAuth();
+    return auth.sessionToken;
+}
+export async function getStoredGithubToken() {
+    if (process.env.GITHUB_TOKEN) {
+        return process.env.GITHUB_TOKEN;
+    }
+    const auth = await loadAuth();
+    return auth.githubToken;
+}
+export async function getStoredBaseUrl() {
+    if (process.env.PRLEN_BASE_URL) {
+        return process.env.PRLEN_BASE_URL;
+    }
+    const auth = await loadAuth();
+    return auth.baseUrl;
+}

package/dist/lib/github.js

@@ -0,0 +1,137 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const LANGUAGE_MAP = {
+    '.py': 'Python',
+    '.js': 'JavaScript',
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.jsx': 'JavaScript',
+    '.rs': 'Rust',
+    '.go': 'Go',
+    '.rb': 'Ruby',
+    '.java': 'Java',
+    '.kt': 'Kotlin',
+    '.swift': 'Swift',
+    '.c': 'C',
+    '.cpp': 'C++',
+    '.cs': 'C#',
+    '.php': 'PHP',
+    '.html': 'HTML',
+    '.css': 'CSS',
+    '.scss': 'SCSS',
+    '.vue': 'Vue',
+    '.svelte': 'Svelte',
+    '.sql': 'SQL',
+    '.sh': 'Shell',
+    '.ex': 'Elixir',
+    '.exs': 'Elixir',
+    '.zig': 'Zig',
+};
+function parseGitHubUrl(url) {
+    const match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/.*)?$/i);
+    if (!match) {
+        return null;
+    }
+    const [, owner, repo, prNumber] = match;
+    return {
+        owner,
+        repo,
+        prNumber: Number.parseInt(prNumber, 10),
+        prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
+        repoFullName: `${owner}/${repo}`,
+    };
+}
+function parseGitRemote(remoteUrl) {
+    const httpsMatch = remoteUrl.trim().match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    const sshMatch = remoteUrl.trim().match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    return null;
+}
+async function getOriginRemote() {
+    const { stdout } = await execFileAsync('git', ['remote', 'get-url', 'origin']);
+    const parsed = parseGitRemote(stdout);
+    if (!parsed) {
+        throw new Error('Could not resolve a GitHub repo from git remote origin');
+    }
+    return parsed;
+}
+export async function resolvePullRequestReference(prRef) {
+    const normalized = prRef.trim();
+    const fromUrl = parseGitHubUrl(normalized);
+    if (fromUrl) {
+        return fromUrl;
+    }
+    const numberMatch = normalized.match(/^#?(\d+)$/);
+    if (!numberMatch) {
+        throw new Error('Expected a GitHub PR URL, #123, or 123');
+    }
+    const { owner, repo } = await getOriginRemote();
+    const prNumber = Number.parseInt(numberMatch[1], 10);
+    return {
+        owner,
+        repo,
+        prNumber,
+        prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
+        repoFullName: `${owner}/${repo}`,
+    };
+}
+function inferLanguages(files) {
+    const languages = new Set();
+    for (const file of files) {
+        const extensionMatch = file.filename.match(/(\.[^.\/]+)$/);
+        if (!extensionMatch) {
+            continue;
+        }
+        const language = LANGUAGE_MAP[extensionMatch[1].toLowerCase()];
+        if (language) {
+            languages.add(language);
+        }
+    }
+    return [...languages].sort();
+}
+export async function fetchPullRequestMetadata(pr, githubToken) {
+    const headers = new Headers({
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        Authorization: `Bearer ${githubToken}`,
+    });
+    const prResponse = await fetch(`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, { headers });
+    if (!prResponse.ok) {
+        throw new Error(`Failed to fetch pull request: ${prResponse.status}`);
+    }
+    const prJson = await prResponse.json();
+    const files = [];
+    let page = 1;
+    while (true) {
+        const filesResponse = await fetch(`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}/files?per_page=100&page=${page}`, { headers });
+        if (!filesResponse.ok) {
+            throw new Error(`Failed to fetch pull request files: ${filesResponse.status}`);
+        }
+        const pageFiles = await filesResponse.json();
+        if (pageFiles.length === 0) {
+            break;
+        }
+        files.push(...pageFiles);
+        if (pageFiles.length < 100) {
+            break;
+        }
+        page += 1;
+    }
+    return {
+        pr_title: prJson.title,
+        pr_url: prJson.html_url,
+        pr_number: prJson.number,
+        repo_full_name: pr.repoFullName,
+        pr_body: prJson.body ?? '',
+        files_changed: prJson.changed_files,
+        additions: prJson.additions,
+        deletions: prJson.deletions,
+        languages: inferLanguages(files),
+    };
+}

package/dist/lib/skills.js

@@ -0,0 +1,50 @@
+import { mkdir, rm, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function packageSkillDir() {
+    return fileURLToPath(new URL('../../skills/prlen/', import.meta.url));
+}
+export function normalizeTargets(target) {
+    if (target === 'both') {
+        return ['claude', 'codex'];
+    }
+    return [target];
+}
+export function targetRoot(target) {
+    if (target === 'claude') {
+        return path.join(process.env.CLAUDE_HOME || path.join(homedir(), '.claude'), 'skills');
+    }
+    return path.join(process.env.CODEX_HOME || path.join(homedir(), '.codex'), 'skills');
+}
+export function targetDir(target) {
+    return path.join(targetRoot(target), 'prlen');
+}
+export async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getSkillStatus(target) {
+    const destination = targetDir(target);
+    return {
+        target,
+        destination,
+        installed: await pathExists(destination),
+    };
+}
+export async function ensureTargetRoot(target) {
+    await mkdir(targetRoot(target), { recursive: true });
+}
+export async function removeInstalledSkill(target) {
+    const destination = targetDir(target);
+    const exists = await pathExists(destination);
+    if (exists) {
+        await rm(destination, { recursive: true, force: true });
+    }
+    return exists;
+}

package/dist/utils/ui.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+function wrapText(text, width) {
+    const words = text.split(/\s+/).filter(Boolean);
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        const candidate = current ? `${current} ${word}` : word;
+        if (candidate.length > width && current) {
+            lines.push(current);
+            current = word;
+        }
+        else {
+            current = candidate;
+        }
+    }
+    if (current) {
+        lines.push(current);
+    }
+    return lines.length ? lines : [''];
+}
+export function printPreviewBox(text, width = 58) {
+    const lines = wrapText(text, width);
+    const top = `┌${'─'.repeat(width + 2)}┐`;
+    const bottom = `└${'─'.repeat(width + 2)}┘`;
+    console.log(chalk.dim(top));
+    for (const line of lines) {
+        const padded = line.padEnd(width, ' ');
+        console.log(chalk.dim('│ ') + padded + chalk.dim(' │'));
+    }
+    console.log(chalk.dim(bottom));
+}
+export async function confirm(message) {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = (await rl.question(`${message} `)).trim().toLowerCase();
+        return answer === '' || answer === 'y' || answer === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export function printMuted(text) {
+    console.log(chalk.dim(text));
+}
+export function printSuccess(text) {
+    console.log(chalk.green(`✓ ${text}`));
+}
+export function printError(text) {
+    console.error(chalk.red(text));
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@metmirr/prlen",
+  "version": "0.1.0",
+  "description": "CLI for publishing PR Lens posts from pull requests",
+  "type": "module",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "bin": {
+    "prlen": "dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1",
+    "ora": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}

package/skills/prlen/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: prlen
+description: Publish or create PR Lens posts for a GitHub pull request. Use when the user asks to post to PR Lens, create a PR Lens post, or publish PR #123 to their PR Lens feed from a Claude or Codex session.
+---
+
+# PR Lens
+
+Use this skill when the user wants an agent to publish a PR Lens post for a pull request.
+
+## Goal
+
+Use the fastest reliable workflow:
+
+1. Resolve the PR reference (`#12`, `12`, or a full GitHub PR URL)
+2. Read enough PR context to draft a good short post
+3. Draft the PR Lens post text yourself
+4. Publish non-interactively via the CLI using stdin
+
+The agent is already an LLM, so do **not** wait for the CLI to generate the text.
+
+## Preferred publish command
+
+```bash
+printf '%s' "<draft post text>" | prlen post 12 --prompt-stdin --yes
+```
+
+## PR Lens post style
+
+Write like a real developer talking to Claude/Cursor/Copilot:
+
+- casual and direct
+- 2–3 sentences max
+- specific technologies, file paths, and decisions when visible
+- under 500 chars
+- instruction-style wording, not release notes
+- no quotes, no labels
+
+Good:
+
+```text
+Add CLI publishing for PR Lens with browser-approved login, backend-fetched PR metadata, and non-interactive posting for agents. Keep it simple: login in the browser once, then let the CLI publish directly from the terminal.
+```
+
+Bad:
+
+```text
+This PR adds several new features to improve the PR Lens platform.
+```
+
+## Workflow
+
+### 1. Resolve the PR
+
+Prefer the user's PR reference directly.
+
+- `#12`
+- `12`
+- `https://github.com/org/repo/pull/12`
+
+### 2. Inspect the PR
+
+Read enough context to write a high-quality short post:
+
+- PR title
+- PR description/body
+- changed files
+- important parts of the diff
+- notable implementation constraints or design choices
+
+### 3. Optionally fetch the PR Lens prompt template
+
+If you want style guidance, fetch:
+
+```text
+GET /api/v1/prompt-template
+```
+
+Do not block on this if you already have enough context to write the post.
+
+### 4. Publish via CLI
+
+Use stdin to avoid shell-escaping problems.
+
+```bash
+printf '%s' "<draft post text>" | prlen post 12 --prompt-stdin --yes
+```
+
+### 5. Report the result
+
+Tell the user the post was published and include the returned URL.
+
+## Auth expectations
+
+PR Lens CLI auth usually comes from:
+
+- `~/.config/prlen/auth.json`
+- `PRLEN_TOKEN`
+
+If auth is missing, tell the user to run:
+
+```bash
+prlen login
+```
+
+`prlen login` opens a browser approval page on PR Lens. If the user is already signed in on the website, they can approve the CLI login there without manually handling GitHub tokens.
+
+## Notes
+
+- `prlen post` fetches PR metadata through PR Lens using the user's connected GitHub account.
+- The target repository must already be connected in PR Lens.
+- The pull request must not already have a PR Lens post.
+
+See [reference.md](reference.md) for examples and fallback behavior.

package/skills/prlen/reference.md

@@ -0,0 +1,53 @@
+# PR Lens Skill Reference
+
+## Common commands
+
+### Log in once
+
+```bash
+prlen login
+```
+
+This opens a browser approval page on PR Lens.
+
+### Publish PR #12 with agent-authored text
+
+```bash
+printf '%s' "Add API-backed PR Lens publishing for pull requests with browser-approved login and non-interactive agent mode." | prlen post 12 --prompt-stdin --yes
+```
+
+### Full PR URL instead of number
+
+```bash
+printf '%s' "Add API-backed PR Lens publishing for pull requests with browser-approved login and non-interactive agent mode." | prlen post https://github.com/org/repo/pull/12 --prompt-stdin --yes
+```
+
+## Fallbacks
+
+### If prompt text is already available as a string
+
+```bash
+prlen post 12 --prompt "<draft post text>" --yes
+```
+
+`--prompt-stdin` is still safer for agents.
+
+## What to write
+
+Aim for:
+
+- the instruction that produced the code
+- constraints or design choices
+- names of files/tech when relevant
+- no markdown formatting
+- no surrounding quotes
+
+## If publishing fails
+
+Check:
+
+1. PR Lens auth exists (`prlen login`)
+2. the repo is connected in PR Lens
+3. the PR does not already have a post
+4. the daily post limit has not been reached
+5. the PR Lens server URL is correct if using a local instance (`PRLEN_BASE_URL`)