@agentuity/cli 1.0.14 → 1.0.15

package/src/cmd/git/identity/disconnect.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
+import { disconnectGithubIntegration, getGithubIntegrationStatus } from '../api';
+
+const DisconnectOptionsSchema = z.object({
+	confirm: z.boolean().optional().describe('Skip confirmation prompt'),
+});
+
+const DisconnectResponseSchema = z.object({
+	disconnected: z.boolean().describe('Whether the identity was disconnected'),
+});
+
+export const disconnectSubcommand = createSubcommand({
+	name: 'disconnect',
+	description: 'Disconnect your GitHub identity and all installations',
+	tags: ['mutating', 'destructive', 'slow'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	schema: {
+		options: DisconnectOptionsSchema,
+		response: DisconnectResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git identity disconnect'),
+			description: 'Disconnect your GitHub identity',
+		},
+		{
+			command: getCommand('git identity disconnect --confirm'),
+			description: 'Disconnect without confirmation prompt',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, opts, options } = ctx;
+
+		try {
+			const status = await tui.spinner({
+				message: 'Checking GitHub connection...',
+				clearOnSuccess: true,
+				callback: () => getGithubIntegrationStatus(apiClient),
+			});
+
+			if (!status.connected || !status.identity) {
+				if (!options.json) {
+					tui.newline();
+					tui.info('No GitHub identity connected.');
+				}
+				return { disconnected: false };
+			}
+
+			if (!opts.confirm) {
+				tui.newline();
+				tui.output(
+					`Connected as ${tui.bold(status.identity.githubUsername)} with ${status.installations.length} installation${status.installations.length !== 1 ? 's' : ''}.`
+				);
+				tui.newline();
+
+				const confirmed = await tui.confirm(
+					'Are you sure you want to disconnect your GitHub identity?'
+				);
+				if (!confirmed) {
+					tui.info('Cancelled');
+					return { disconnected: false };
+				}
+			}
+
+			await tui.spinner({
+				message: 'Disconnecting GitHub identity...',
+				clearOnSuccess: true,
+				callback: () => disconnectGithubIntegration(apiClient),
+			});
+
+			if (!options.json) {
+				tui.newline();
+				tui.success('Disconnected GitHub identity and all installations');
+			}
+
+			return { disconnected: true };
+		} catch (error) {
+			const isCancel =
+				error === '' ||
+				(error instanceof Error &&
+					(error.message === '' || error.message === 'User cancelled'));
+
+			if (isCancel) {
+				tui.newline();
+				tui.info('Cancelled');
+				return { disconnected: false };
+			}
+
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to disconnect GitHub identity: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});

package/src/cmd/git/identity/index.ts

@@ -0,0 +1,10 @@
+import { createCommand } from '../../../types';
+import { connectSubcommand } from './connect';
+import { disconnectSubcommand } from './disconnect';
+import { statusSubcommand } from './status';
+
+export const identityCommand = createCommand({
+	name: 'identity',
+	description: 'Manage your GitHub identity',
+	subcommands: [connectSubcommand, disconnectSubcommand, statusSubcommand],
+});

package/src/cmd/git/identity/status.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
+import { getGithubIntegrationStatus } from '../api';
+
+const StatusResponseSchema = z.object({
+	connected: z.boolean().describe('Whether a GitHub identity is connected'),
+	identity: z
+		.object({
+			githubUsername: z.string().describe('GitHub username'),
+			githubEmail: z.string().optional().describe('GitHub email'),
+		})
+		.nullable()
+		.describe('Connected GitHub identity'),
+});
+
+export const statusSubcommand = createSubcommand({
+	name: 'status',
+	description: 'Show your connected GitHub identity',
+	tags: ['read-only'],
+	idempotent: true,
+	requires: { auth: true, apiClient: true },
+	schema: {
+		response: StatusResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git identity status'),
+			description: 'Show your connected GitHub identity',
+		},
+		{
+			command: getCommand('--json git identity status'),
+			description: 'Show identity in JSON format',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, options } = ctx;
+
+		try {
+			const status = await tui.spinner({
+				message: 'Checking GitHub connection...',
+				clearOnSuccess: true,
+				callback: () => getGithubIntegrationStatus(apiClient),
+			});
+
+			const result = {
+				connected: status.connected,
+				identity: status.identity
+					? {
+							githubUsername: status.identity.githubUsername,
+							githubEmail: status.identity.githubEmail,
+						}
+					: null,
+			};
+
+			if (options.json) {
+				return result;
+			}
+
+			tui.newline();
+			tui.output(tui.bold('GitHub Identity'));
+			tui.newline();
+
+			if (!status.connected || !status.identity) {
+				tui.output(
+					tui.muted(
+						`No GitHub identity connected. Run ${tui.bold('agentuity git identity connect')} to connect one.`
+					)
+				);
+				tui.newline();
+				return result;
+			}
+
+			tui.output(
+				`  ${tui.colorSuccess('✓')} Connected as ${tui.bold(status.identity.githubUsername)}`
+			);
+			if (status.identity.githubEmail) {
+				tui.output(`    Email: ${status.identity.githubEmail}`);
+			}
+
+			tui.newline();
+
+			return result;
+		} catch (error) {
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to check GitHub identity: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});

package/src/cmd/git/index.ts

@@ -1,14 +1,16 @@
 import { createCommand } from '../../types';
 import { accountCommand } from './account';
+import { identityCommand } from './identity';
 import { linkSubcommand } from './link';
 import { listSubcommand } from './list';
-import { unlinkSubcommand } from './unlink';
 import { statusSubcommand } from './status';
+import { unlinkSubcommand } from './unlink';
 
 export const gitCommand = createCommand({
 	name: 'git',
 	description: 'Manage GitHub integration and repository connections',
 	subcommands: [
+		identityCommand,
 		accountCommand,
 		linkSubcommand,
 		listSubcommand,
@@ -16,5 +18,3 @@ export const gitCommand = createCommand({
 		statusSubcommand,
 	],
 });
-
-export default gitCommand;

package/src/cmd/git/link.ts

@@ -1,19 +1,20 @@
-import { createSubcommand, type Config } from '../../types';
-import * as tui from '../../tui';
-import { getCommand } from '../../command-prefix';
-import { ErrorCode } from '../../errors';
+import type { Logger } from '@agentuity/core';
 import enquirer from 'enquirer';
 import { z } from 'zod';
+import type { APIClient } from '../../api';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+import * as tui from '../../tui';
+import { type Config, createSubcommand } from '../../types';
 import {
+	type GithubInstallation,
+	type GithubRepo,
 	getGithubIntegrationStatus,
-	listGithubRepos,
-	linkProjectToRepo,
 	getProjectGithubStatus,
-	type GithubRepo,
+	linkProjectToRepo,
+	listGithubRepos,
 } from './api';
-import type { APIClient } from '../../api';
-import type { Logger } from '@agentuity/core';
-import { runGitAccountConnect } from './account/add';
+import { runGitIdentityConnect } from './identity/connect';
 
 export interface DetectedGitInfo {
 	repo: string | null;
@@ -60,7 +61,6 @@ export function detectGitInfo(): DetectedGitInfo {
 export interface RunGitLinkOptions {
 	apiClient: APIClient;
 	projectId: string;
-	orgId: string;
 	logger: Logger;
 	branchOption?: string;
 	rootOption?: string;
@@ -84,7 +84,6 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 	const {
 		apiClient,
 		projectId,
-		orgId,
 		logger,
 		branchOption,
 		rootOption,
@@ -120,12 +119,12 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 		let githubStatus = await tui.spinner({
 			message: 'Checking GitHub connection...',
 			clearOnSuccess: true,
-			callback: () => getGithubIntegrationStatus(apiClient, orgId),
+			callback: () => getGithubIntegrationStatus(apiClient),
 		});
 
-		if (!githubStatus.connected || githubStatus.integrations.length === 0) {
+		if (!githubStatus.connected || githubStatus.installations.length === 0) {
 			tui.newline();
-			tui.warning('No GitHub accounts connected to this organization.');
+			tui.warning('No GitHub accounts connected.');
 			tui.newline();
 
 			const wantConnect = await tui.confirm('Would you like to connect a GitHub account now?');
@@ -134,9 +133,8 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 				return { linked: false, cancelled: true };
 			}
 
-			const connectResult = await runGitAccountConnect({
+			const connectResult = await runGitIdentityConnect({
 				apiClient,
-				orgId,
 				logger,
 				config,
 			});
@@ -148,9 +146,9 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 				return { linked: false, noGithubConnected: true };
 			}
 
-			githubStatus = await getGithubIntegrationStatus(apiClient, orgId);
+			githubStatus = await getGithubIntegrationStatus(apiClient);
 
-			if (!githubStatus.connected || githubStatus.integrations.length === 0) {
+			if (!githubStatus.connected || githubStatus.installations.length === 0) {
 				tui.error('GitHub connection failed. Please try again.');
 				return { linked: false, noGithubConnected: true };
 			}
@@ -165,7 +163,7 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 		const allRepos = await tui.spinner({
 			message: 'Fetching available repositories...',
 			clearOnSuccess: true,
-			callback: () => listGithubRepos(apiClient, orgId),
+			callback: () => listGithubRepos(apiClient),
 		});
 
 		if (allRepos.length === 0) {
@@ -198,14 +196,16 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 		if (!selectedRepo) {
 			let repos = allRepos;
 
-			if (githubStatus.integrations.length > 1) {
+			if (githubStatus.installations.length > 1) {
 				tui.newline();
 
-				const accountChoices = githubStatus.integrations.map((integration) => ({
-					name: integration.githubAccountName,
-					value: integration.id,
-					message: `${integration.githubAccountName} ${tui.muted(`(${integration.githubAccountType})`)}`,
-				}));
+				const accountChoices = githubStatus.installations.map(
+					(installation: GithubInstallation) => ({
+						name: installation.accountName,
+						value: installation.integrationId ?? installation.installationId,
+						message: `${installation.accountName} ${tui.muted(`(${installation.accountType})`)}`,
+					})
+				);
 
 				const accountResponse = await enquirer.prompt<{ integrationId: string }>({
 					type: 'select',
@@ -213,8 +213,10 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 					message: 'Select a GitHub account',
 					choices: accountChoices,
 					result(name: string) {
-						// Return the value (id) instead of the name
-						const choice = accountChoices.find((c) => c.name === name);
+						// Return the value (integrationId) instead of the name
+						const choice = accountChoices.find(
+							(c: { name: string; value: string; message: string }) => c.name === name
+						);
 						return choice?.value ?? name;
 					},
 				});
@@ -222,7 +224,7 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 				repos = await tui.spinner({
 					message: 'Fetching repositories...',
 					clearOnSuccess: true,
-					callback: () => listGithubRepos(apiClient, orgId, accountResponse.integrationId),
+					callback: () => listGithubRepos(apiClient, accountResponse.integrationId),
 				});
 
 				if (repos.length === 0) {
@@ -254,7 +256,7 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 		}
 
 		// Prompt for settings with defaults
-		const defaultBranch = branchOption ?? gitInfo.branch ?? selectedRepo.defaultBranch;
+		const defaultBranch = branchOption ?? selectedRepo.defaultBranch;
 		const defaultRoot = rootOption ?? '.';
 
 		tui.newline();
@@ -309,7 +311,6 @@ export async function runGitLink(options: RunGitLinkOptions): Promise<RunGitLink
 					autoDeploy: finalAutoDeploy,
 					previewDeploy: finalPreviewDeploy,
 					directory: directory === '.' ? undefined : directory,
-					integrationId: selectedRepo.integrationId,
 				}),
 		});
 
@@ -414,9 +415,6 @@ export const linkSubcommand = createSubcommand({
 
 		try {
 			// Non-interactive mode when repo is provided
-			// Note: integrationId is not passed in non-interactive mode. The API will
-			// attempt to find a matching integration based on the repo owner. This may
-			// fail if the org has multiple GitHub integrations with access to the same repo.
 			if (opts.repo && opts.confirm) {
 				const branch = opts.branch ?? 'main';
 				const directory = opts.root === '.' ? undefined : opts.root;
@@ -446,7 +444,6 @@ export const linkSubcommand = createSubcommand({
 			const result = await runGitLink({
 				apiClient,
 				projectId: project.projectId,
-				orgId: project.orgId,
 				logger,
 				branchOption: opts.branch,
 				rootOption: opts.root,

package/src/cmd/git/list.ts

@@ -1,20 +1,18 @@
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
-import { getCommand } from '../../command-prefix';
 import enquirer from 'enquirer';
 import { z } from 'zod';
-import { getGithubIntegrationStatus, listGithubRepos } from './api';
+import { getCommand } from '../../command-prefix';
 import { ErrorCode } from '../../errors';
-import { listOrganizations } from '@agentuity/server';
+import * as tui from '../../tui';
+import { createSubcommand } from '../../types';
+import { getGithubIntegrationStatus, listGithubRepos } from './api';
 
 const ListOptionsSchema = z.object({
-	org: z.string().optional().describe('Organization ID to list repos for'),
-	account: z.string().optional().describe('GitHub account/integration ID to filter by'),
+	account: z.string().optional().describe('GitHub account name to filter by'),
 });
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
-	description: 'List GitHub repositories accessible to your organization',
+	description: 'List GitHub repositories accessible to your account',
 	aliases: ['ls'],
 	tags: ['read-only'],
 	idempotent: true,
@@ -28,8 +26,8 @@ export const listSubcommand = createSubcommand({
 			description: 'List all accessible GitHub repositories',
 		},
 		{
-			command: getCommand('git list --org org_abc123'),
-			description: 'List repos for a specific organization',
+			command: getCommand('git list --account my-org'),
+			description: 'List repos for a specific GitHub account',
 		},
 		{
 			command: getCommand('--json git list'),
@@ -41,78 +39,69 @@ export const listSubcommand = createSubcommand({
 		const { logger, apiClient, opts, options } = ctx;
 
 		try {
-			// Get orgs
-			const orgs = await tui.spinner({
-				message: 'Fetching organizations...',
-				clearOnSuccess: true,
-				callback: () => listOrganizations(apiClient),
-			});
-
-			if (orgs.length === 0) {
-				tui.error('No organizations found');
-				return [];
-			}
-
-			// Select org
-			let orgId = opts.org;
-			if (!orgId) {
-				const firstOrg = orgs[0];
-				if (orgs.length === 1 && firstOrg) {
-					orgId = firstOrg.id;
-				} else {
-					tui.newline();
-					const orgChoices = orgs.map((o) => ({
-						name: o.id,
-						message: o.name,
-					}));
-
-					const response = await enquirer.prompt<{ orgId: string }>({
-						type: 'select',
-						name: 'orgId',
-						message: 'Select an organization',
-						choices: orgChoices,
-					});
-					orgId = response.orgId;
-				}
-			}
-
-			// Check GitHub integrations
+			// Check GitHub connection
 			const githubStatus = await tui.spinner({
 				message: 'Checking GitHub connection...',
 				clearOnSuccess: true,
-				callback: () => getGithubIntegrationStatus(apiClient, orgId!),
+				callback: () => getGithubIntegrationStatus(apiClient),
 			});
 
-			if (!githubStatus.connected || githubStatus.integrations.length === 0) {
+			if (!githubStatus.connected || githubStatus.installations.length === 0) {
 				tui.newline();
-				tui.error('No GitHub accounts connected to this organization.');
+				tui.error('No GitHub accounts connected.');
 				console.log(tui.muted(`Run ${tui.bold('agentuity git account add')} to connect one`));
 				return [];
 			}
 
-			// Select account if multiple and not specified
-			let integrationId = opts.account;
-			if (!integrationId && githubStatus.integrations.length > 1) {
+			// Select installation if multiple and not specified
+			let integrationId: string | undefined;
+
+			if (opts.account) {
+				// Match by account name
+				const matched = githubStatus.installations.find(
+					(inst) => inst.accountName.toLowerCase() === opts.account!.toLowerCase()
+				);
+				if (!matched) {
+					tui.newline();
+					tui.error(`No installation found for account "${opts.account}"`);
+					console.log(
+						tui.muted(
+							`Available: ${githubStatus.installations.map((i) => i.accountName).join(', ')}`
+						)
+					);
+					return [];
+				}
+				integrationId = matched.integrationId;
+			} else if (githubStatus.installations.length > 1) {
 				tui.newline();
-				const accountChoices = githubStatus.integrations.map((integration) => ({
-					name: integration.id,
-					message: `${integration.githubAccountName} ${tui.muted(`(${integration.githubAccountType})`)}`,
+				const accountChoices = githubStatus.installations.map((installation) => ({
+					name: installation.installationId,
+					message: `${installation.accountName} ${tui.muted(`(${installation.accountType})`)}`,
+					value: installation.integrationId,
 				}));
 
-				const response = await enquirer.prompt<{ integrationId: string }>({
+				const response = await enquirer.prompt<{ installationId: string }>({
 					type: 'select',
-					name: 'integrationId',
+					name: 'installationId',
 					message: 'Select a GitHub account',
 					choices: accountChoices,
+					result(name: string) {
+						// Return the value (integrationId) instead of the display name
+						const choice = accountChoices.find((c) => c.name === name);
+						return choice?.value ?? name;
+					},
 				});
-				integrationId = response.integrationId;
+				integrationId = response.installationId;
+			} else {
+				// Single installation — use its integrationId
+				integrationId = githubStatus.installations[0]?.integrationId;
 			}
 
 			// Fetch repos
 			const repos = await tui.spinner({
 				message: 'Fetching repositories...',
 				clearOnSuccess: true,
-				callback: () => listGithubRepos(apiClient, orgId!, integrationId),
+				callback: () => listGithubRepos(apiClient, integrationId),
 			});
 
 			if (repos.length === 0) {