@falldownthesystem/devtool 0.1.0

package/src/commands/pr.js

@@ -0,0 +1,132 @@
+import { Command } from 'commander';
+import {
+	listPullRequests,
+	getPullRequest,
+	getPullRequestComments,
+	getPullRequestDiffstat,
+	getPullRequestActivity,
+} from '../clients/bitbucket.js';
+import {
+	formatPrList, formatPrView, formatPrComments, formatPrDiffstat, formatPrActivity,
+	plainPrList, plainPrView, plainPrComments, plainPrDiffstat, plainPrActivity,
+	curateListJson, curateViewJson, curateCommentsJson, curateDiffstatJson, curateActivityJson,
+} from '../formatters/pr.js';
+import { spinner } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+import { getOutputMode, outputJson } from '../utils/mode.js';
+
+function withMode(cmd, fetchFn, { json, plain, rich }) {
+	return async (...args) => {
+		const mode = getOutputMode(cmd);
+		const s = mode === 'rich' ? spinner('Loading...').start() : null;
+		try {
+			const data = await fetchFn(...args);
+			if (s) s.success({ text: '' });
+			if (mode === 'json') outputJson(json(data));
+			else if (mode === 'plain') plain(data);
+			else rich(data);
+		} catch (err) {
+			if (s) s.error({ text: 'Failed' });
+			handleError(err, err.url || 'bitbucket');
+		}
+	};
+}
+
+const pr = new Command('pr')
+	.description('Bitbucket pull requests');
+
+pr.command('list')
+	.alias('ls')
+	.description('List pull requests')
+	.option('-s, --state <state>', 'PR state (OPEN, MERGED, DECLINED)', 'OPEN')
+	.option('-a, --author <name>', 'Filter by author')
+	.option('-r, --repo <slug>', 'Repository slug (overrides default)')
+	.action(async function (opts) {
+		const mode = getOutputMode(this);
+		const s = mode === 'rich' ? spinner('Fetching pull requests...').start() : null;
+		try {
+			const prs = await listPullRequests({ state: opts.state, author: opts.author, repo: opts.repo });
+			if (s) s.success({ text: `${prs.length} pull request(s) found` });
+			if (mode === 'json') outputJson(curateListJson(prs));
+			else if (mode === 'plain') plainPrList(prs);
+			else formatPrList(prs);
+		} catch (err) {
+			if (s) s.error({ text: 'Failed to fetch pull requests' });
+			handleError(err, err.url || 'bitbucket');
+		}
+	});
+
+pr.command('view <id>')
+	.alias('read')
+	.description('View pull request details')
+	.option('-r, --repo <slug>', 'Repository slug (overrides default)')
+	.action(async function (id, opts) {
+		const mode = getOutputMode(this);
+		const s = mode === 'rich' ? spinner(`Fetching PR #${id}...`).start() : null;
+		try {
+			const data = await getPullRequest(id, opts.repo);
+			if (s) s.success({ text: `PR #${id}` });
+			if (mode === 'json') outputJson(curateViewJson(data));
+			else if (mode === 'plain') plainPrView(data);
+			else formatPrView(data);
+		} catch (err) {
+			if (s) s.error({ text: `Failed to fetch PR #${id}` });
+			handleError(err, err.url || 'bitbucket');
+		}
+	});
+
+pr.command('comments <id>')
+	.description('List pull request comments')
+	.option('-r, --repo <slug>', 'Repository slug (overrides default)')
+	.action(async function (id, opts) {
+		const mode = getOutputMode(this);
+		const s = mode === 'rich' ? spinner(`Fetching comments for PR #${id}...`).start() : null;
+		try {
+			const comments = await getPullRequestComments(id, opts.repo);
+			if (s) s.success({ text: `${comments.length} comment(s)` });
+			if (mode === 'json') outputJson(curateCommentsJson(comments));
+			else if (mode === 'plain') plainPrComments(comments);
+			else formatPrComments(comments);
+		} catch (err) {
+			if (s) s.error({ text: `Failed to fetch comments for PR #${id}` });
+			handleError(err, err.url || 'bitbucket');
+		}
+	});
+
+pr.command('diff <id>')
+	.description('Show pull request diffstat')
+	.option('-r, --repo <slug>', 'Repository slug (overrides default)')
+	.action(async function (id, opts) {
+		const mode = getOutputMode(this);
+		const s = mode === 'rich' ? spinner(`Fetching diffstat for PR #${id}...`).start() : null;
+		try {
+			const files = await getPullRequestDiffstat(id, opts.repo);
+			if (s) s.success({ text: `${files.length} file(s) changed` });
+			if (mode === 'json') outputJson(curateDiffstatJson(files));
+			else if (mode === 'plain') plainPrDiffstat(files);
+			else formatPrDiffstat(files);
+		} catch (err) {
+			if (s) s.error({ text: `Failed to fetch diffstat for PR #${id}` });
+			handleError(err, err.url || 'bitbucket');
+		}
+	});
+
+pr.command('activity <id>')
+	.description('Show pull request activity')
+	.option('-r, --repo <slug>', 'Repository slug (overrides default)')
+	.action(async function (id, opts) {
+		const mode = getOutputMode(this);
+		const s = mode === 'rich' ? spinner(`Fetching activity for PR #${id}...`).start() : null;
+		try {
+			const activities = await getPullRequestActivity(id, opts.repo);
+			if (s) s.success({ text: `${activities.length} activity item(s)` });
+			if (mode === 'json') outputJson(curateActivityJson(activities));
+			else if (mode === 'plain') plainPrActivity(activities);
+			else formatPrActivity(activities);
+		} catch (err) {
+			if (s) s.error({ text: `Failed to fetch activity for PR #${id}` });
+			handleError(err, err.url || 'bitbucket');
+		}
+	});
+
+export default pr;

package/src/config/store.js

@@ -0,0 +1,156 @@
+import Conf from 'conf';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+
+const schema = {
+	bitbucket: {
+		type: 'object',
+		properties: {
+			workspace: { type: 'string' },
+			defaultRepo: { type: 'string' },
+			email: { type: 'string' },
+			token: { type: 'string' },
+		},
+	},
+	jira: {
+		type: 'object',
+		properties: {
+			baseUrl: { type: 'string' },
+			token: { type: 'string' },
+			defaultProject: { type: 'string' },
+		},
+	},
+	confluence: {
+		type: 'object',
+		properties: {
+			baseUrl: { type: 'string' },
+			email: { type: 'string' },
+			token: { type: 'string' },
+			defaultSpace: { type: 'string' },
+		},
+	},
+};
+
+const config = new Conf({
+	projectName: 'devtool',
+	schema,
+	defaults: {
+		bitbucket: { workspace: '', defaultRepo: '', email: '', token: '' },
+		jira: { baseUrl: '', token: '', defaultProject: '' },
+		confluence: { baseUrl: '', email: '', token: '', defaultSpace: '' },
+	},
+});
+
+export function get(key) {
+	return config.get(key);
+}
+
+export function set(key, value) {
+	config.set(key, value);
+}
+
+export function getAll() {
+	return config.store;
+}
+
+export function isConfigured() {
+	const bb = config.get('bitbucket');
+	const jira = config.get('jira');
+	return !!(bb.workspace && bb.token && jira.baseUrl && jira.token);
+}
+
+export function configPath() {
+	return config.path;
+}
+
+export async function runSetup() {
+	p.intro(pc.cyan('DevTool Setup'));
+
+	const bb = await p.group({
+		workspace: () => p.text({
+			message: 'Bitbucket workspace slug',
+			placeholder: 'my-workspace',
+			initialValue: config.get('bitbucket.workspace') || '',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+		defaultRepo: () => p.text({
+			message: 'Bitbucket default repo slug',
+			placeholder: 'my-repo',
+			initialValue: config.get('bitbucket.defaultRepo') || '',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+		email: () => p.text({
+			message: 'Bitbucket account email',
+			placeholder: 'you@company.com',
+			initialValue: config.get('bitbucket.email') || '',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+		token: () => p.password({
+			message: 'Bitbucket API token',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+	}, {
+		onCancel: () => {
+			p.cancel('Setup cancelled.');
+			process.exit(0);
+		},
+	});
+
+	const jira = await p.group({
+		baseUrl: () => p.text({
+			message: 'Jira Server base URL',
+			placeholder: 'https://jira.company.com',
+			initialValue: config.get('jira.baseUrl') || '',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+		token: () => p.password({
+			message: 'Jira Personal Access Token',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+		defaultProject: () => p.text({
+			message: 'Jira default project key',
+			placeholder: 'PROJ',
+			initialValue: config.get('jira.defaultProject') || '',
+			validate: (v) => !v ? 'Required' : undefined,
+		}),
+	}, {
+		onCancel: () => {
+			p.cancel('Setup cancelled.');
+			process.exit(0);
+		},
+	});
+
+	const confluence = await p.group({
+		baseUrl: () => p.text({
+			message: 'Confluence Cloud base URL',
+			placeholder: 'https://company.atlassian.net',
+			initialValue: config.get('confluence.baseUrl') || '',
+		}),
+		email: () => p.text({
+			message: 'Confluence account email',
+			placeholder: 'you@company.com',
+			initialValue: config.get('confluence.email') || '',
+		}),
+		token: () => p.password({
+			message: 'Confluence API token',
+		}),
+		defaultSpace: () => p.text({
+			message: 'Confluence default space key',
+			placeholder: 'DEV',
+			initialValue: config.get('confluence.defaultSpace') || '',
+		}),
+	}, {
+		onCancel: () => {
+			p.cancel('Setup cancelled.');
+			process.exit(0);
+		},
+	});
+
+	config.set('bitbucket', bb);
+	config.set('jira', jira);
+	config.set('confluence', confluence);
+
+	p.outro(pc.green('Configuration saved!'));
+}
+
+export default config;

package/src/formatters/confluence.js

@@ -0,0 +1,212 @@
+import { table, heading, field, divider, pc } from '../utils/output.js';
+
+function stripHtml(html) {
+	if (!html) return '';
+	return html
+		.replace(/<br\s*\/?>/gi, '\n')
+		.replace(/<\/p>/gi, '\n')
+		.replace(/<\/li>/gi, '\n')
+		.replace(/<\/h[1-6]>/gi, '\n')
+		.replace(/<[^>]+>/g, '')
+		.replace(/&amp;/g, '&')
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/&nbsp;/g, ' ')
+		.replace(/\n{3,}/g, '\n\n')
+		.trim();
+}
+
+function relativeTime(dateStr) {
+	if (!dateStr) return '';
+	const diff = Date.now() - new Date(dateStr).getTime();
+	const mins = Math.floor(diff / 60000);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	const days = Math.floor(hours / 24);
+	if (days < 30) return `${days}d ago`;
+	return new Date(dateStr).toLocaleDateString();
+}
+
+function spaceType(type) {
+	if (!type) return '';
+	if (type === 'global') return pc.blue('global');
+	if (type === 'personal') return pc.dim('personal');
+	return type;
+}
+
+// --- JSON curators ---
+
+export function curateSpacesJson(spaces) {
+	return spaces.map((s) => ({
+		id: s.id,
+		key: s.key,
+		name: s.name,
+		type: s.type || null,
+		status: s.status || null,
+	}));
+}
+
+export function curatePageJson(page) {
+	return {
+		id: page.id,
+		title: page.title,
+		spaceId: page.spaceId || null,
+		status: page.status || null,
+		createdAt: page.createdAt || null,
+		version: page.version?.number || null,
+		body: stripHtml(page.body?.storage?.value),
+	};
+}
+
+export function curatePagesJson(pages) {
+	return pages.map((p) => ({
+		id: p.id,
+		title: p.title,
+		status: p.status || null,
+		createdAt: p.createdAt || null,
+		version: p.version?.number || null,
+	}));
+}
+
+export function curateSearchJson(result) {
+	return {
+		totalSize: result.totalSize || 0,
+		results: (result.results || []).map((r) => ({
+			title: r.content?.title || r.title || '',
+			id: r.content?.id || r.id || null,
+			type: r.content?.type || r.type || null,
+			space: r.resultGlobalContainer?.title || null,
+			excerpt: stripHtml(r.excerpt),
+			url: r.url || null,
+			lastModified: r.lastModified || r.content?.version?.when || null,
+		})),
+	};
+}
+
+// --- Plain formatters ---
+
+export function plainSpaces(spaces) {
+	if (spaces.length === 0) { console.log('No spaces found.'); return; }
+	for (const s of spaces) {
+		console.log(`${s.key} "${s.name}" (${s.type || 'unknown'}, ${s.status || 'current'})`);
+	}
+}
+
+export function plainPageView(page) {
+	console.log(`${page.id} ${page.title}`);
+	if (page.spaceId) console.log(`Space ID: ${page.spaceId}`);
+	console.log(`Status: ${page.status || 'current'}`);
+	if (page.version?.number) console.log(`Version: ${page.version.number}`);
+	if (page.createdAt) console.log(`Created: ${page.createdAt}`);
+	const body = stripHtml(page.body?.storage?.value);
+	if (body) console.log(`Content:\n${body}`);
+}
+
+export function plainPages(pages) {
+	if (pages.length === 0) { console.log('No pages found.'); return; }
+	for (const p of pages) {
+		console.log(`${p.id} "${p.title}" (${p.status || 'current'})`);
+	}
+}
+
+export function plainSearch(result) {
+	const results = result.results || [];
+	if (results.length === 0) { console.log('No results found.'); return; }
+	for (const r of results) {
+		const title = r.content?.title || r.title || 'Untitled';
+		const id = r.content?.id || '';
+		const space = r.resultGlobalContainer?.title || '';
+		const excerpt = stripHtml(r.excerpt).split('\n')[0].slice(0, 100);
+		console.log(`${id} [${space}] "${title}" - ${excerpt}`);
+	}
+	if (result.totalSize > results.length) {
+		console.log(`Showing ${results.length} of ${result.totalSize} results`);
+	}
+}
+
+// --- Rich formatters ---
+
+export function formatSpaces(spaces) {
+	if (spaces.length === 0) {
+		console.log(pc.dim('  No spaces found.'));
+		return;
+	}
+
+	const rows = spaces.map((s) => [
+		pc.bold(s.key),
+		s.name || '',
+		spaceType(s.type),
+		s.status || 'current',
+	]);
+
+	console.log(table(['Key', 'Name', 'Type', 'Status'], rows));
+}
+
+export function formatPageView(page) {
+	heading(`${page.title}`);
+	divider();
+	field('Page ID', page.id);
+	if (page.spaceId) field('Space ID', page.spaceId);
+	field('Status', page.status || 'current');
+	if (page.version?.number) field('Version', page.version.number);
+	if (page.createdAt) field('Created', new Date(page.createdAt).toLocaleString());
+
+	const body = stripHtml(page.body?.storage?.value);
+	if (body) {
+		heading('Content');
+		const lines = body.split('\n');
+		const truncated = lines.slice(0, 50);
+		for (const line of truncated) {
+			console.log(`  ${line}`);
+		}
+		if (lines.length > 50) {
+			console.log(pc.dim(`  ... (${lines.length - 50} more lines)`));
+		}
+	}
+
+	console.log('');
+}
+
+export function formatPages(pages) {
+	if (pages.length === 0) {
+		console.log(pc.dim('  No pages found.'));
+		return;
+	}
+
+	const rows = pages.map((p) => [
+		p.id,
+		(p.title || '').length > 60 ? p.title.slice(0, 57) + '...' : (p.title || ''),
+		p.status || 'current',
+		p.version?.number || '',
+		relativeTime(p.createdAt),
+	]);
+
+	console.log(table(['ID', 'Title', 'Status', 'Version', 'Created'], rows));
+}
+
+export function formatSearch(result) {
+	const results = result.results || [];
+	if (results.length === 0) {
+		console.log(pc.dim('  No results found.'));
+		return;
+	}
+
+	const rows = results.map((r) => [
+		r.content?.id || '',
+		(r.content?.title || r.title || '').length > 50
+			? (r.content?.title || r.title || '').slice(0, 47) + '...'
+			: (r.content?.title || r.title || ''),
+		r.resultGlobalContainer?.title || '',
+		stripHtml(r.excerpt).split('\n')[0].slice(0, 60),
+	]);
+
+	console.log(table(['ID', 'Title', 'Space', 'Excerpt'], rows));
+
+	if (result.totalSize > results.length) {
+		console.log(pc.dim(`  Showing ${results.length} of ${result.totalSize} results`));
+	}
+	console.log('');
+}