@agentuity/cli 0.1.6 → 0.1.8

package/src/cmd/build/vite/agent-discovery.ts

@@ -46,11 +46,146 @@ interface ASTCallExpression extends ASTNode {
 	callee: ASTNode;
 }
 
+interface ASTMemberExpression extends ASTNode {
+	object: ASTNode;
+	property: ASTNode;
+	computed?: boolean;
+}
+
 interface ASTVariableDeclarator extends ASTNode {
 	id: ASTNode;
 	init?: ASTNode;
 }
 
+interface ASTVariableDeclaration extends ASTNode {
+	declarations: ASTVariableDeclarator[];
+}
+
+interface ASTExportNamedDeclaration extends ASTNode {
+	declaration?: ASTNode;
+}
+
+interface ASTProgram {
+	type: string;
+	body: ASTNode[];
+}
+
+/**
+ * Type for identifier resolver function
+ */
+type IdentifierResolver = (name: string) => ASTNode | undefined;
+
+/**
+ * Build a file-local identifier resolver that maps top-level variable names
+ * to their initializer AST nodes. This allows resolving schema variable references.
+ */
+function buildIdentifierResolver(program: ASTProgram): IdentifierResolver {
+	const initMap = new Map<string, ASTNode>();
+
+	for (const node of program.body) {
+		// const x = ... or let x = ... or var x = ...
+		if (node.type === 'VariableDeclaration') {
+			const decl = node as unknown as ASTVariableDeclaration;
+			for (const d of decl.declarations) {
+				if (d.id.type === 'Identifier' && d.init) {
+					const id = d.id as ASTNodeIdentifier;
+					initMap.set(id.name, d.init);
+				}
+			}
+		}
+
+		// export const x = ...
+		if (node.type === 'ExportNamedDeclaration') {
+			const exp = node as unknown as ASTExportNamedDeclaration;
+			if (exp.declaration && exp.declaration.type === 'VariableDeclaration') {
+				const decl = exp.declaration as unknown as ASTVariableDeclaration;
+				for (const d of decl.declarations) {
+					if (d.id.type === 'Identifier' && d.init) {
+						const id = d.id as ASTNodeIdentifier;
+						initMap.set(id.name, d.init);
+					}
+				}
+			}
+		}
+	}
+
+	return (name: string) => initMap.get(name);
+}
+
+/**
+ * Get the property name from an AST node (Identifier or Literal).
+ */
+function getPropertyName(node: ASTNode): string | undefined {
+	if (node.type === 'Identifier') {
+		return (node as ASTNodeIdentifier).name;
+	}
+	if (node.type === 'Literal') {
+		const lit = node as ASTLiteral;
+		return typeof lit.value === 'string' ? lit.value : undefined;
+	}
+	return undefined;
+}
+
+/**
+ * Resolve an expression by following identifier references and member access chains.
+ * Applies a recursion limit to prevent infinite loops from cyclic references.
+ *
+ * Supported patterns:
+ * - Identifiers: `AgentInput` -> resolves to variable definition
+ * - Member access: `configs.agent1.schema` -> traverses object literals
+ */
+function resolveExpression(
+	node: ASTNode,
+	resolveIdentifier: IdentifierResolver,
+	depth = 0
+): ASTNode {
+	if (!node) return node;
+	if (depth > 8) return node; // Prevent cycles / deep alias chains
+
+	// Follow identifiers to their definitions
+	if (node.type === 'Identifier') {
+		const id = node as ASTNodeIdentifier;
+		const resolved = resolveIdentifier(id.name);
+		if (resolved) {
+			return resolveExpression(resolved, resolveIdentifier, depth + 1);
+		}
+	}
+
+	// Follow member expressions: configs.agent1.schema, baseSchemas.shared
+	if (node.type === 'MemberExpression') {
+		const memberExpr = node as unknown as ASTMemberExpression;
+
+		// Skip computed properties like configs[agentName]
+		if (memberExpr.computed) return node;
+
+		const propName = getPropertyName(memberExpr.property);
+		if (!propName) return node;
+
+		// First resolve the object side (e.g., configs -> { agent1: {...} })
+		const resolvedObj = resolveExpression(memberExpr.object, resolveIdentifier, depth + 1);
+
+		// If we got an object literal, look up the property
+		if (resolvedObj.type === 'ObjectExpression') {
+			const obj = resolvedObj as ASTObjectExpression;
+			for (const prop of obj.properties) {
+				// Skip spread elements
+				if (!prop || !('key' in prop) || !prop.key) continue;
+
+				const keyName = getPropertyName(prop.key);
+				if (keyName === propName && prop.value) {
+					// Recurse into the property value
+					return resolveExpression(prop.value as ASTNode, resolveIdentifier, depth + 1);
+				}
+			}
+		}
+
+		// Couldn't resolve - return original node
+		return node;
+	}
+
+	return node;
+}
+
 export interface AgentMetadata {
 	filename: string;
 	name: string;
@@ -117,9 +252,43 @@ function generateStableEvalId(projectId: string, agentId: string, name: string):
 }
 
 /**
- * Extract schema code from createAgent call arguments
+ * Check if a property key matches a given name.
+ * Handles both Identifier keys (schema) and Literal keys ('schema').
  */
-function extractSchemaCode(callargexp: ASTObjectExpression): {
+function isKeyNamed(prop: ASTPropertyNode, name: 'schema' | 'input' | 'output'): boolean {
+	if (!prop || !prop.key) return false;
+
+	if (prop.key.type === 'Identifier') {
+		return (prop.key as ASTNodeIdentifier).name === name;
+	}
+	if (prop.key.type === 'Literal') {
+		const lit = prop.key as unknown as ASTLiteral;
+		return typeof lit.value === 'string' && lit.value === name;
+	}
+	return false;
+}
+
+/**
+ * Extract schema code from createAgent call arguments.
+ * Resolves variable references to their actual definitions when possible.
+ *
+ * Supported patterns:
+ * - Inline schema: `schema: { input: s.object({...}), output: s.object({...}) }`
+ * - Variable reference: `schema: { input: AgentInput, output: AgentOutput }`
+ * - Schema object variable: `schema: schemaVar` where schemaVar is a top-level const
+ * - Shorthand: `schema: { input, output }` where input/output are top-level consts
+ *
+ * Unsupported patterns (returns empty or partial result):
+ * - Config alias: `createAgent('x', configVar)` - config must be inline object
+ * - Schema from member access: `schema: configs.agent1.schema`
+ * - Schema from function call: `schema: getSchema()`
+ * - Destructured variables: `const { schema } = config`
+ * - Cross-file imports (falls back to identifier name)
+ */
+function extractSchemaCode(
+	callargexp: ASTObjectExpression,
+	resolveIdentifier: IdentifierResolver
+): {
 	inputSchemaCode?: string;
 	outputSchemaCode?: string;
 } {
@@ -127,9 +296,16 @@ function extractSchemaCode(callargexp: ASTObjectExpression): {
 
 	// Find the schema property
 	for (const prop of callargexp.properties) {
-		if (prop.key.type === 'Identifier' && prop.key.name === 'schema') {
-			if (prop.value.type === 'ObjectExpression') {
-				schemaObj = prop.value as ASTObjectExpression;
+		// Skip spread elements or any non-Property nodes
+		if (!prop || !('key' in prop) || !prop.key) continue;
+
+		if (isKeyNamed(prop, 'schema')) {
+			// Resolve the schema value if it's an identifier (e.g., schema: schemaVar)
+			let valueNode = prop.value as ASTNode;
+			valueNode = resolveExpression(valueNode, resolveIdentifier);
+
+			if (valueNode.type === 'ObjectExpression') {
+				schemaObj = valueNode as ASTObjectExpression;
 				break;
 			}
 		}
@@ -144,12 +320,17 @@ function extractSchemaCode(callargexp: ASTObjectExpression): {
 
 	// Extract input and output schema code
 	for (const prop of schemaObj.properties) {
-		if (prop.key.type === 'Identifier') {
-			if (prop.key.name === 'input' && prop.value) {
-				inputSchemaCode = formatSchemaCode(generate(prop.value));
-			} else if (prop.key.name === 'output' && prop.value) {
-				outputSchemaCode = formatSchemaCode(generate(prop.value));
-			}
+		// Skip spread elements or any non-Property nodes
+		if (!prop || !('key' in prop) || !prop.key) continue;
+
+		if (isKeyNamed(prop, 'input') && prop.value) {
+			// Resolve variable reference if the value is an identifier
+			const resolvedValue = resolveExpression(prop.value as ASTNode, resolveIdentifier);
+			inputSchemaCode = formatSchemaCode(generate(resolvedValue));
+		} else if (isKeyNamed(prop, 'output') && prop.value) {
+			// Resolve variable reference if the value is an identifier
+			const resolvedValue = resolveExpression(prop.value as ASTNode, resolveIdentifier);
+			outputSchemaCode = formatSchemaCode(generate(resolvedValue));
 		}
 	}
 
@@ -179,13 +360,19 @@ function extractAgentMetadata(
 	projectId: string,
 	deploymentId: string
 ): AgentMetadata | null {
-	const ast = acornLoose.parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
+	const ast = acornLoose.parse(code, {
+		ecmaVersion: 'latest',
+		sourceType: 'module',
+	}) as ASTProgram;
+
+	// Build identifier resolver for resolving schema variable references
+	const resolveIdentifier = buildIdentifierResolver(ast);
 
 	// Calculate file version (hash of contents)
 	const version = hash(code);
 
 	// Find createAgent calls
-	for (const node of (ast as { body: ASTNode[] }).body) {
+	for (const node of ast.body) {
 		if (node.type === 'ExportDefaultDeclaration') {
 			const declaration = (node as unknown as { declaration: ASTNode }).declaration;
 
@@ -204,8 +391,11 @@ function extractAgentMetadata(
 					// Second arg is config object
 					const callargexp = callExpr.arguments[1] as ASTObjectExpression;
 
-					// Extract schemas
-					const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(callargexp);
+					// Extract schemas (with variable resolution)
+					const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(
+						callargexp,
+						resolveIdentifier
+					);
 
 					// Extract description from either direct property or metadata object
 					let description: string | undefined;
@@ -262,7 +452,10 @@ function extractAgentMetadata(
 						const name = String(nameArg.value);
 
 						const callargexp = callExpr.arguments[1] as ASTObjectExpression;
-						const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(callargexp);
+						const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(
+							callargexp,
+							resolveIdentifier
+						);
 
 						let description: string | undefined;
 						for (const prop of callargexp.properties) {

package/src/cmd/build/vite/docs-generator.ts

@@ -20,8 +20,10 @@ This directory contains auto-generated TypeScript files created by the Agentuity
 - \`registry.ts\` - Agent registry from \`src/agent/**\`
 - \`routes.ts\` - Route registry from \`src/api/**\`
 - \`app.ts\` - Application entry point
-- \`state.ts\` - App state types (when setup() exists)
-- \`router.ts\` - Runtime wrapper (when setup() exists)
+- \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
+- \`webanalytics.ts\` - Web analytics injection and route registration
+- \`state.ts\` - App state type (only generated when \`setup()\` returns state in \`app.ts\`)
+- \`router.ts\` - Runtime wrapper with type augmentation (only generated when \`setup()\` returns state in \`app.ts\`)
 
 ## For Developers
 
@@ -50,8 +52,10 @@ const AGENTS_MD_CONTENT = `# AI Agent Instructions
 - \`registry.ts\` - Built from agent discovery in \`src/agent/\`
 - \`routes.ts\` - Built from route discovery in \`src/api/\`
 - \`app.ts\` - Entry point assembled from project configuration
-- \`state.ts\` - App state type from \`setup()\` return value
-- \`router.ts\` - Runtime wrapper with type augmentation
+- \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
+- \`webanalytics.ts\` - Web analytics injection and route registration
+- \`state.ts\` - App state type (only generated when \`setup()\` returns state in \`app.ts\`)
+- \`router.ts\` - Runtime wrapper with type augmentation (only generated when \`setup()\` returns state)
 
 These files are regenerated on every \`bun run build\` or \`bun run dev\`.
 `;

package/src/cmd/build/vite/registry-generator.ts

@@ -935,11 +935,15 @@ ${routeSchemaTypes}
  * Route Definitions
  * 
  * Type-safe route registry for all API routes, WebSocket connections, and SSE endpoints.
- * Used by @agentuity/react for client-side type-safe routing.
+ * Used by @agentuity/react and @agentuity/frontend for client-side type-safe routing.
  * 
  * @remarks
  * This module augmentation is auto-generated from your route files during build.
  * Individual route Input/Output types are exported above for direct usage.
+ * 
+ * The augmentation targets @agentuity/frontend (the canonical source of registry types).
+ * Since @agentuity/react re-exports these types, the augmentation is visible when
+ * importing from either package.
  */
 ${
 	shouldEmitFrontendClient
@@ -956,7 +960,7 @@ ${rpcRegistryType}
 `
 		: ''
 }
-declare module '@agentuity/react' {
+declare module '@agentuity/frontend' {
 \t/**
 \t * API Route Registry
 \t * 
@@ -988,13 +992,34 @@ ${sseRouteEntries}
 \t * RPC Route Registry
 \t * 
 \t * Nested structure for RPC-style client access (e.g., client.hello.post())
-\t * Used by createClient() from @agentuity/core for type-safe RPC calls.
+\t * Used by createClient() from @agentuity/frontend for type-safe RPC calls.
 \t */
 \texport interface RPCRouteRegistry {
 ${rpcRegistryType}
 \t}
 }
-
+${
+	hasReactDependency
+		? `
+// Backward compatibility: also augment @agentuity/react for older versions
+// that define RouteRegistry locally instead of re-exporting from @agentuity/frontend
+declare module '@agentuity/react' {
+\texport interface RouteRegistry {
+${apiRouteEntries}
+\t}
+\texport interface WebSocketRouteRegistry {
+${websocketRouteEntries}
+\t}
+\texport interface SSERouteRegistry {
+${sseRouteEntries}
+\t}
+\texport interface RPCRouteRegistry {
+${rpcRegistryType}
+\t}
+}
+`
+		: ''
+}
 /**
  * Runtime metadata for RPC routes.
  * Contains route type information for client routing decisions.

package/src/cmd/build/vite/server-bundler.ts

@@ -66,7 +66,9 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 
 	// Build tool externals: packages that should be external but NOT installed
 	// These are devDependencies that may exist in node_modules but aren't needed at runtime
-	const buildToolExternals = ['@babel/*', 'lightningcss', '@vitejs/*', 'vite', 'esbuild'];
+	// NOTE: @babel/* is NOT externalized because some runtime deps (e.g., puppeteer → cosmiconfig → parse-json)
+	// require @babel/code-frame at runtime. Babel packages are pure JS and bundle fine.
+	const buildToolExternals = ['lightningcss', '@vitejs/*', 'vite', 'esbuild'];
 
 	// Load custom externals and define from agentuity.config.ts if it exists
 	const customExternals: string[] = [];
@@ -194,10 +196,7 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 			// Use npm with --force for cross-platform installs since Bun's --target flag
 			// doesn't correctly handle optional dependencies for other platforms
 			const allPackagesToInstall = [...externalInstalls, ...platformOptionalDeps];
-			logger.debug(
-				'Installing with npm (cross-platform): %s',
-				allPackagesToInstall.join(', ')
-			);
+			logger.debug('Installing with npm (cross-platform): %s', allPackagesToInstall.join(', '));
 
 			const proc = Bun.spawn(
 				[

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -70,9 +70,12 @@ export async function generateAssetServerConfig(
 			dedupe: ['react', 'react-dom', 'react/jsx-runtime', 'react/jsx-dev-runtime'],
 		},
 
-		// Pre-bundle @agentuity/workbench to avoid React preamble issues with pre-built JSX
+		// Pre-bundle dependencies to avoid React preamble issues with pre-built JSX
+		// Only include @agentuity/workbench if workbench is enabled
 		optimizeDeps: {
-			include: ['@agentuity/workbench', '@agentuity/core', '@agentuity/react'],
+			include: workbenchPath
+				? ['@agentuity/workbench', '@agentuity/core', '@agentuity/react']
+				: ['@agentuity/core', '@agentuity/react'],
 		},
 
 		// Only allow frontend env vars (server uses process.env)

package/src/cmd/canary/index.ts

@@ -0,0 +1,214 @@
+import { createCommand } from '../../types';
+import { getPlatformInfo } from '../upgrade';
+import { downloadWithProgress } from '../../download';
+import { z } from 'zod';
+import { $ } from 'bun';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readdir, rm, mkdir, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import * as tui from '../../tui';
+
+const CANARY_CACHE_DIR = join(homedir(), '.agentuity', 'canary');
+const CANARY_BASE_URL = 'https://agentuity-sdk-objects.t3.storage.dev/binary';
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+const CanaryArgsSchema = z.object({
+	args: z
+		.array(z.string())
+		.describe('Version/URL followed by commands to run (e.g., 0.1.6-abc1234 deploy --force)'),
+});
+
+const CanaryResponseSchema = z.object({
+	executed: z.boolean().describe('Whether the canary was executed'),
+	version: z.string().describe('The canary version'),
+	message: z.string().describe('Status message'),
+});
+
+function isUrl(str: string): boolean {
+	return str.startsWith('http://') || str.startsWith('https://');
+}
+
+function getBinaryFilename(platform: { os: string; arch: string }): string {
+	return `agentuity-${platform.os}-${platform.arch}.gz`;
+}
+
+function getCachePath(version: string): string {
+	return join(CANARY_CACHE_DIR, version, 'agentuity');
+}
+
+function hashUrl(url: string): string {
+	return createHash('sha256').update(url).digest('hex').slice(0, 12);
+}
+
+async function cleanupOldCanaries(): Promise<void> {
+	try {
+		await mkdir(CANARY_CACHE_DIR, { recursive: true });
+		const entries = await readdir(CANARY_CACHE_DIR);
+		const now = Date.now();
+
+		for (const entry of entries) {
+			const entryPath = join(CANARY_CACHE_DIR, entry);
+			try {
+				const stats = await stat(entryPath);
+				if (now - stats.mtimeMs > CACHE_MAX_AGE_MS) {
+					await rm(entryPath, { recursive: true, force: true });
+				}
+			} catch {
+				// Ignore errors for individual entries
+			}
+		}
+	} catch {
+		// Ignore cleanup errors
+	}
+}
+
+async function downloadCanary(url: string, destPath: string): Promise<void> {
+	const destDir = join(destPath, '..');
+	await mkdir(destDir, { recursive: true });
+
+	const gzPath = `${destPath}.gz`;
+
+	const stream = await downloadWithProgress({
+		url,
+		message: 'Downloading canary...',
+	});
+
+	const writer = Bun.file(gzPath).writer();
+	for await (const chunk of stream) {
+		writer.write(chunk);
+	}
+	await writer.end();
+
+	if (!(await Bun.file(gzPath).exists())) {
+		throw new Error('Download failed - file not created');
+	}
+
+	try {
+		await $`gunzip ${gzPath}`.quiet();
+	} catch (error) {
+		if (await Bun.file(gzPath).exists()) {
+			await $`rm ${gzPath}`.quiet();
+		}
+		throw new Error(
+			`Decompression failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+		);
+	}
+
+	if (!(await Bun.file(destPath).exists())) {
+		throw new Error('Decompression failed - file not found');
+	}
+
+	await $`chmod 755 ${destPath}`.quiet();
+}
+
+export const command = createCommand({
+	name: 'canary',
+	description: 'Run a canary version of the CLI',
+	hidden: true,
+	skipUpgradeCheck: true,
+	passThroughArgs: true,
+	schema: {
+		args: CanaryArgsSchema,
+		response: CanaryResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+
+		// Get raw args from process.argv to capture ALL args after 'canary <version>'
+		// This ensures we forward everything including flags like --json, --force, etc.
+		const argv = process.argv;
+		const canaryIndex = argv.indexOf('canary');
+
+		if (args.args.length === 0) {
+			tui.error('Usage: agentuity canary <version|url> [commands...]');
+			tui.newline();
+			tui.info('Examples:');
+			tui.info('  agentuity canary 0.1.6-abc1234');
+			tui.info('  agentuity canary 0.1.6-abc1234 deploy --log-level trace');
+			tui.info(
+				'  agentuity canary https://agentuity-sdk-objects.t3.storage.dev/binary/0.1.6-abc1234/agentuity-darwin-arm64.gz'
+			);
+			return {
+				executed: false,
+				version: '',
+				message: 'No target specified',
+			};
+		}
+
+		// Get target from parsed args, but get forward args from raw argv
+		// This captures ALL args after the version including any flags
+		const target = args.args[0];
+		const targetIndex = canaryIndex >= 0 ? argv.indexOf(target, canaryIndex) : -1;
+		const forwardArgs = targetIndex >= 0 ? argv.slice(targetIndex + 1) : args.args.slice(1);
+
+		// Clean up old canaries in background
+		cleanupOldCanaries().catch(() => {});
+
+		const platform = getPlatformInfo();
+		let version: string;
+		let downloadUrl: string;
+		let cachePath: string;
+
+		if (isUrl(target)) {
+			// Extract version from URL, or create a unique hash for custom URLs
+			const match = target.match(/\/binary\/([^/]+)\//);
+			version = match ? match[1] : `custom-${hashUrl(target)}`;
+			downloadUrl = target;
+			cachePath = getCachePath(version);
+		} else {
+			// Treat as version string
+			version = target;
+			const filename = getBinaryFilename(platform);
+			downloadUrl = `${CANARY_BASE_URL}/${version}/${filename}`;
+			cachePath = getCachePath(version);
+		}
+
+		// Check cache
+		if (await Bun.file(cachePath).exists()) {
+			tui.info(`Using cached canary ${version}`);
+		} else {
+			tui.info(`Downloading canary ${version}...`);
+			try {
+				await downloadCanary(downloadUrl, cachePath);
+				tui.success(`Downloaded canary ${version}`);
+			} catch (error) {
+				tui.error(
+					`Failed to download canary: ${error instanceof Error ? error.message : 'Unknown error'}`
+				);
+				return {
+					executed: false,
+					version,
+					message: `Failed to download: ${error instanceof Error ? error.message : 'Unknown error'}`,
+				};
+			}
+		}
+
+		// Update access time
+		try {
+			await $`touch -a -m ${cachePath}`.quiet();
+		} catch {
+			// Ignore touch errors
+		}
+
+		tui.newline();
+		tui.info(`Running canary ${version}...`);
+		tui.newline();
+
+		// Execute the canary binary with forwarded args
+		// Skip version check in the canary binary to avoid upgrade prompts
+		const proc = Bun.spawn([cachePath, ...forwardArgs], {
+			stdin: 'inherit',
+			stdout: 'inherit',
+			stderr: 'inherit',
+			env: {
+				...process.env,
+				AGENTUITY_SKIP_VERSION_CHECK: '1',
+			},
+		});
+
+		const exitCode = await proc.exited;
+		process.exit(exitCode);
+	},
+});

package/src/cmd/cloud/deploy.ts

@@ -14,7 +14,7 @@ import {
 	loadProjectSDKKey,
 	updateProjectConfig,
 } from '../../config';
-import { getProjectGithubStatus } from '../integration/api';
+import { getProjectGithubStatus } from '../git/api';
 import { runGitLink } from '../git/link';
 import {
 	runSteps,

package/src/cmd/git/account/add.ts

@@ -15,7 +15,7 @@ import {
 	getGithubIntegrationStatus,
 	getExistingGithubIntegrations,
 	copyGithubIntegration,
-} from '../../integration/api';
+} from '../api';
 
 export interface RunGitAccountConnectOptions {
 	apiClient: APIClient;

package/src/cmd/git/account/list.ts

@@ -3,7 +3,7 @@ import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { listOrganizations } from '@agentuity/server';
-import { getGithubIntegrationStatus } from '../../integration/api';
+import { getGithubIntegrationStatus } from '../api';
 import { z } from 'zod';
 
 const ListResponseSchema = z.array(

package/src/cmd/git/account/remove.ts

@@ -9,7 +9,7 @@ import {
 	getGithubIntegrationStatus,
 	disconnectGithubIntegration,
 	type GithubIntegration,
-} from '../../integration/api';
+} from '../api';
 
 const RemoveOptionsSchema = z.object({
 	org: z.string().optional().describe('Organization ID'),

package/src/cmd/git/link.ts

@@ -10,7 +10,7 @@ import {
 	linkProjectToRepo,
 	getProjectGithubStatus,
 	type GithubRepo,
-} from '../integration/api';
+} from './api';
 import type { APIClient } from '../../api';
 import type { Logger } from '@agentuity/core';
 import { runGitAccountConnect } from './account/add';

package/src/cmd/git/list.ts

@@ -3,7 +3,7 @@ import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
 import enquirer from 'enquirer';
 import { z } from 'zod';
-import { getGithubIntegrationStatus, listGithubRepos } from '../integration/api';
+import { getGithubIntegrationStatus, listGithubRepos } from './api';
 import { ErrorCode } from '../../errors';
 import { listOrganizations } from '@agentuity/server';