@agentuity/cli 2.0.7 → 2.0.9

package/src/cmd/coder/replay.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+
+export const replaySubcommand = createSubcommand({
+	name: 'replay',
+	description: 'Get replay data for a Coder Hub session',
+	tags: ['read-only', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder replay codesess_abc123 --json'),
+			description: 'Get replay data as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to get replay data for'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const replay = await client.getReplay(args.sessionId);
+
+			if (!options.json) {
+				tui.info('Replay data is shown as JSON because it is a complex payload.');
+				tui.output(JSON.stringify(replay, null, 2));
+			}
+
+			return replay;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(
+				`Failed to get replay for session ${args.sessionId}: ${msg}`,
+				ErrorCode.NETWORK_ERROR
+			);
+		}
+	},
+});

package/src/cmd/coder/resolve-repo.ts

@@ -0,0 +1,119 @@
+import type { CoderClient, CoderSessionRepositoryRef } from '@agentuity/core/coder';
+
+/**
+ * Parse a GitHub reference string into owner/repo/branch.
+ * Accepts:
+ *   - github.com/owner/repo
+ *   - https://github.com/owner/repo
+ *   - https://github.com/owner/repo.git
+ *   - owner/repo
+ *   - owner/repo#branch
+ *   - https://github.com/owner/repo/tree/branch
+ */
+export function parseGitHubRef(
+	input: string
+): { owner: string; repo: string; branch?: string } | null {
+	let clean = input.trim();
+
+	// Handle owner/repo#branch
+	let branch: string | undefined;
+	const hashIdx = clean.indexOf('#');
+	if (hashIdx > 0) {
+		branch = clean.slice(hashIdx + 1);
+		clean = clean.slice(0, hashIdx);
+	}
+
+	// Handle URLs
+	if (clean.includes('github.com')) {
+		try {
+			const url = new URL(clean.startsWith('http') ? clean : `https://${clean}`);
+			const parts = url.pathname
+				.replace(/^\//, '')
+				.replace(/\.git$/, '')
+				.split('/');
+			const owner = parts[0];
+			const repo = parts[1];
+			if (parts.length >= 2 && owner && repo) {
+				// Handle /tree/branch paths
+				if (parts.length >= 4 && parts[2] === 'tree') {
+					branch = branch || parts.slice(3).join('/');
+				}
+				return { owner, repo, branch };
+			}
+		} catch {
+			// fall through
+		}
+	}
+
+	// Handle owner/repo
+	const slashParts = clean.replace(/\.git$/, '').split('/');
+	if (slashParts.length === 2 && slashParts[0] && slashParts[1]) {
+		return { owner: slashParts[0], repo: slashParts[1], branch };
+	}
+
+	return null;
+}
+
+/**
+ * Resolve a GitHub reference to a full repository ref by calling the Hub's GitHub APIs.
+ *
+ * Flow:
+ * 1. Parse the input to get owner/repo
+ * 2. List GitHub accounts → find the one matching the owner
+ * 3. List repos for that account → find the matching repo
+ * 4. Build full CoderSessionRepositoryRef with all metadata
+ */
+export async function resolveGitHubRepo(
+	client: CoderClient,
+	input: string,
+	branchOverride?: string
+): Promise<CoderSessionRepositoryRef> {
+	const parsed = parseGitHubRef(input);
+	if (!parsed) {
+		throw new Error(`Could not parse GitHub reference: ${input}`);
+	}
+
+	const { owner, repo, branch: parsedBranch } = parsed;
+	const branch = branchOverride || parsedBranch;
+
+	// Step 1: List GitHub accounts
+	const accountsResponse = await client.listGitHubAccounts();
+	if (!accountsResponse.connected) {
+		throw new Error('GitHub is not connected. Please connect GitHub via the Coder web UI first.');
+	}
+
+	const account = accountsResponse.accounts.find(
+		(a) => a.accountName.toLowerCase() === owner.toLowerCase()
+	);
+	if (!account) {
+		const available = accountsResponse.accounts.map((a) => a.accountName).join(', ');
+		throw new Error(
+			`GitHub account "${owner}" not found. Available accounts: ${available || 'none'}`
+		);
+	}
+
+	// Step 2: List repos for that account
+	const reposResponse = await client.listGitHubRepos(account.accountId);
+	const repoMatch = reposResponse.repositories.find(
+		(r) => r.name.toLowerCase() === repo.toLowerCase()
+	);
+	if (!repoMatch) {
+		throw new Error(`Repository "${repo}" not found in GitHub account "${owner}".`);
+	}
+
+	// Step 3: Build full repo ref
+	return {
+		url: repoMatch.cloneUrl,
+		branch: branch || repoMatch.defaultBranch,
+		provider: 'github',
+		name: repoMatch.name,
+		fullName: repoMatch.fullName,
+		defaultBranch: repoMatch.defaultBranch,
+		private: repoMatch.private,
+		htmlUrl: repoMatch.htmlUrl,
+		accountId: account.accountId,
+		accountName: account.accountName,
+		accountType: account.accountType,
+		accountAvatarUrl: account.avatarUrl,
+	} as CoderSessionRepositoryRef;
+}

package/src/cmd/coder/skill/buckets.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import { CoderClient, type CoderSkillBucket } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+function formatRelativeTime(isoDate: string): string {
+	const parsed = new Date(isoDate).getTime();
+	if (Number.isNaN(parsed)) return 'unknown';
+	const diffMs = Math.max(0, Date.now() - parsed);
+	const seconds = Math.floor(diffMs / 1000);
+	if (seconds < 60) return `${seconds}s ago`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	const days = Math.floor(hours / 24);
+	return `${days}d ago`;
+}
+
+export const bucketsSubcommand = createSubcommand({
+	name: 'buckets',
+	aliases: ['bucket'],
+	description: 'List, create, or delete skill buckets',
+	tags: ['requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder skill buckets'),
+			description: 'List skill buckets',
+		},
+		{
+			command: getCommand('coder skill buckets --create "My Bucket"'),
+			description: 'Create a new skill bucket',
+		},
+		{
+			command: getCommand(
+				'coder skill buckets --create "My Bucket" --description "Frontend skills"'
+			),
+			description: 'Create a skill bucket with description',
+		},
+		{
+			command: getCommand('coder skill buckets --delete bucket_abc123'),
+			description: 'Delete a skill bucket',
+		},
+		{
+			command: getCommand('coder skill buckets --json'),
+			description: 'List skill buckets as JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			create: z.string().optional().describe('Create a new bucket with this name'),
+			delete: z.string().optional().describe('Delete bucket by ID'),
+			description: z
+				.string()
+				.optional()
+				.describe('Description for new bucket (used with --create)'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, options } = ctx;
+
+		// Validate mutually exclusive actions
+		if (opts?.create && opts?.delete) {
+			tui.fatal('Cannot use --create and --delete together.', ErrorCode.VALIDATION_FAILED);
+		}
+		if (opts?.create && !opts.create.trim()) {
+			tui.fatal('--create requires a non-empty bucket name.', ErrorCode.VALIDATION_FAILED);
+		}
+		if (opts?.delete && !opts.delete.trim()) {
+			tui.fatal('--delete requires a non-empty bucket ID.', ErrorCode.VALIDATION_FAILED);
+		}
+		if (opts?.description && !opts?.create) {
+			tui.fatal('--description can only be used with --create.', ErrorCode.VALIDATION_FAILED);
+		}
+
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		// Delete a bucket
+		if (opts?.delete) {
+			if (!options.json) {
+				const confirmed = await tui.confirm(`Delete skill bucket ${opts.delete}?`, false);
+				if (!confirmed) {
+					tui.info('Cancelled.');
+					return { deleted: false, id: opts.delete };
+				}
+			}
+
+			try {
+				await client.deleteSkillBucket(opts.delete);
+			} catch (err) {
+				if (err instanceof ValidationOutputError) {
+					ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+					ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				}
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(
+					`Failed to delete skill bucket ${opts.delete}: ${msg}`,
+					ErrorCode.NETWORK_ERROR
+				);
+			}
+
+			if (options.json) {
+				return { deleted: true, id: opts.delete };
+			}
+
+			tui.success(`Skill bucket ${opts.delete} deleted.`);
+			return { deleted: true, id: opts.delete };
+		}
+
+		// Create a bucket
+		if (opts?.create) {
+			try {
+				const created = await client.createSkillBucket({
+					name: opts.create,
+					...(opts?.description && { description: opts.description }),
+				});
+
+				if (options.json) {
+					return created;
+				}
+
+				tui.success(`Skill bucket ${created.id} created.`);
+				tui.newline();
+				tui.output(`  Name:   ${tui.bold(created.name)}`);
+				if (created.description) {
+					tui.output(`  Desc:   ${created.description}`);
+				}
+				tui.output(`  Skills: ${created.skillCount}`);
+
+				return created;
+			} catch (err) {
+				if (err instanceof ValidationOutputError) {
+					ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+					ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				}
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(`Failed to create skill bucket: ${msg}`, ErrorCode.NETWORK_ERROR);
+				return;
+			}
+		}
+
+		// Default: list buckets
+		let buckets: CoderSkillBucket[] = [];
+		try {
+			const response = await client.listSkillBuckets();
+			buckets = response.buckets;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to list Coder skill buckets: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+
+		if (options.json) {
+			return buckets;
+		}
+
+		if (buckets.length === 0) {
+			tui.info('No Coder skill buckets found.');
+			return [];
+		}
+
+		tui.table(
+			buckets.map((b) => ({
+				ID: b.id,
+				Name: b.name,
+				Skills: String(b.skillCount),
+				Created: formatRelativeTime(b.createdAt),
+			})),
+			[
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Name', alignment: 'left' },
+				{ name: 'Skills', alignment: 'right' },
+				{ name: 'Created', alignment: 'right' },
+			]
+		);
+
+		return buckets;
+	},
+});

package/src/cmd/coder/skill/delete.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const deleteSkillSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm', 'del', 'remove'],
+	description: 'Delete a saved skill from your library',
+	tags: ['destructive', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder skill delete sk_abc123'),
+			description: 'Delete a saved skill',
+		},
+		{
+			command: getCommand('coder skill delete sk_abc123 --json'),
+			description: 'Delete a saved skill and return JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().describe('Saved skill ID to delete'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		if (!options.json) {
+			const confirmed = await tui.confirm(`Delete saved skill ${args.id}?`, false);
+			if (!confirmed) {
+				tui.info('Cancelled.');
+				return { deleted: false, id: args.id };
+			}
+		}
+
+		try {
+			await client.deleteSavedSkill(args.id);
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to delete saved skill ${args.id}: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+
+		if (options.json) {
+			return { deleted: true, id: args.id };
+		}
+
+		tui.success(`Saved skill ${args.id} deleted.`);
+		return { deleted: true, id: args.id };
+	},
+});

package/src/cmd/coder/skill/index.ts

@@ -0,0 +1,35 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { saveSkillSubcommand } from './save';
+import { deleteSkillSubcommand } from './delete';
+import { bucketsSubcommand } from './buckets';
+import { getCommand } from '../../../command-prefix';
+
+export const skillCommand = createCommand({
+	name: 'skill',
+	aliases: ['skills'],
+	description: 'Manage Coder saved skills and skill buckets',
+	tags: ['requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder skill list'),
+			description: 'List saved skills',
+		},
+		{
+			command: getCommand(
+				'coder skill save --repo org/repo --skill-id sk_abc --name "My Skill"'
+			),
+			description: 'Save a skill to your library',
+		},
+		{
+			command: getCommand('coder skill delete sk_abc123'),
+			description: 'Delete a saved skill',
+		},
+		{
+			command: getCommand('coder skill buckets'),
+			description: 'List skill buckets',
+		},
+	],
+	subcommands: [listSubcommand, saveSkillSubcommand, deleteSkillSubcommand, bucketsSubcommand],
+});

package/src/cmd/coder/skill/list.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { CoderClient, type CoderSavedSkill, CoderSavedSkillSchema } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+function formatRelativeTime(isoDate: string): string {
+	const parsed = new Date(isoDate).getTime();
+	if (Number.isNaN(parsed)) return 'unknown';
+	const diffMs = Math.max(0, Date.now() - parsed);
+	const seconds = Math.floor(diffMs / 1000);
+	if (seconds < 60) return `${seconds}s ago`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	const days = Math.floor(hours / 24);
+	return `${days}d ago`;
+}
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List saved skills',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder skill list'),
+			description: 'List saved skills',
+		},
+		{
+			command: getCommand('coder skill list --json'),
+			description: 'Return saved skills as JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+		response: z.array(CoderSavedSkillSchema),
+	},
+	async handler(ctx) {
+		const { options, opts } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		let skills: CoderSavedSkill[] = [];
+		try {
+			const response = await client.listSavedSkills();
+			skills = response.skills;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to list Coder saved skills: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+
+		if (options.json) {
+			return skills;
+		}
+
+		if (skills.length === 0) {
+			tui.info('No Coder saved skills found.');
+			return [];
+		}
+
+		tui.table(
+			skills.map((s) => ({
+				ID: s.id,
+				Name: s.name,
+				Repo: s.repo,
+				Source: s.source,
+				Installs: s.installs !== undefined ? String(s.installs) : '-',
+				Created: formatRelativeTime(s.createdAt),
+			})),
+			[
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Name', alignment: 'left' },
+				{ name: 'Repo', alignment: 'left' },
+				{ name: 'Source', alignment: 'left' },
+				{ name: 'Installs', alignment: 'right' },
+				{ name: 'Created', alignment: 'right' },
+			]
+		);
+
+		return skills;
+	},
+});

package/src/cmd/coder/skill/save.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const saveSkillSubcommand = createSubcommand({
+	name: 'save',
+	aliases: ['add', 'upsert'],
+	description: 'Save a skill to your library',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand(
+				'coder skill save --repo my-org/my-repo --skill-id sk_abc123 --name "My Skill"'
+			),
+			description: 'Save a skill to your library',
+		},
+		{
+			command: getCommand(
+				'coder skill save --repo my-org/my-repo --skill-id sk_abc123 --name "My Skill" --description "Useful skill" --skill-url https://example.com --json'
+			),
+			description: 'Save a skill with all options and return JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			repo: z.string().describe('Repository identifier for the skill'),
+			skillId: z.string().describe('Skill identifier'),
+			name: z.string().describe('Skill name'),
+			description: z.string().optional().describe('Skill description'),
+			skillUrl: z.string().optional().describe('Skill URL'),
+			source: z.string().optional().describe('Skill source (default: registry)'),
+			content: z.string().optional().describe('Skill content'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const saved = await client.saveSkill({
+				repo: opts.repo,
+				skillId: opts.skillId,
+				name: opts.name,
+				...(opts?.description !== undefined && { description: opts.description }),
+				...(opts?.skillUrl !== undefined && { url: opts.skillUrl }),
+				...(opts?.source !== undefined && { source: opts.source }),
+				...(opts?.content !== undefined && { content: opts.content }),
+			});
+
+			if (options.json) {
+				return saved;
+			}
+
+			tui.success(`Skill ${saved.id} saved.`);
+			tui.newline();
+			tui.output(`  Name:   ${tui.bold(saved.name)}`);
+			tui.output(`  Repo:   ${saved.repo}`);
+			tui.output(`  Source: ${saved.source}`);
+			if (saved.description) {
+				tui.output(`  Desc:   ${saved.description}`);
+			}
+
+			return saved;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				tui.fatal(`Failed to save skill: ${err.message}`, ErrorCode.VALIDATION_FAILED);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to save skill: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});