@agentuity/cli 0.1.41 → 0.1.43

package/src/cmd/ai/cadence/status.ts

@@ -1,141 +0,0 @@
-import { z } from 'zod';
-import { createCommand } from '../../../types';
-import * as tui from '../../../tui';
-import { createCadenceKVAdapter, CADENCE_NAMESPACE, getLoopStateKey, parseLoopState } from './util';
-import { getCommand } from '../../../command-prefix';
-
-const CadenceStatusResponseSchema = z.object({
-	found: z.boolean(),
-	loop: z
-		.object({
-			loopId: z.string(),
-			status: z.string(),
-			iteration: z.number(),
-			maxIterations: z.number(),
-			prompt: z.string(),
-			projectLabel: z.string().optional(),
-			sessionId: z.string().optional(),
-			createdAt: z.string(),
-			updatedAt: z.string(),
-			lastError: z.string().optional(),
-		})
-		.optional(),
-});
-
-export const statusSubcommand = createCommand({
-	name: 'status',
-	aliases: ['get', 'show'],
-	description: 'Get status of a Cadence loop',
-	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true },
-	examples: [
-		{ command: getCommand('cadence status lp_auth_impl'), description: 'Get loop status' },
-	],
-	schema: {
-		args: z.object({
-			loopId: z.string().min(1).describe('The loop ID (e.g., lp_auth_impl)'),
-		}),
-		response: CadenceStatusResponseSchema,
-	},
-	idempotent: true,
-
-	async handler(ctx) {
-		const { args, options } = ctx;
-		const kv = await createCadenceKVAdapter(ctx);
-
-		const key = getLoopStateKey(args.loopId);
-		const result = await kv.get(CADENCE_NAMESPACE, key);
-
-		if (!result.exists || !result.data) {
-			if (!options.json) {
-				tui.warning(`Loop ${args.loopId} not found.`);
-			}
-			return { found: false };
-		}
-
-		let data: unknown;
-		if (typeof result.data === 'string') {
-			try {
-				data = JSON.parse(result.data);
-			} catch {
-				if (!options.json) {
-					tui.error(`Failed to parse loop state for ${args.loopId}`);
-				}
-				return { found: false };
-			}
-		} else {
-			data = result.data;
-		}
-
-		const loop = parseLoopState(data);
-		if (!loop) {
-			if (!options.json) {
-				tui.error(`Invalid loop state for ${args.loopId}`);
-			}
-			return { found: false };
-		}
-
-		if (!options.json) {
-			console.log();
-			tui.info(`Cadence Loop: ${tui.colorPrimary(loop.loopId)}`);
-			console.log();
-
-			const details = [
-				['Status', formatStatus(loop.status)],
-				['Iteration', `${loop.iteration} / ${loop.maxIterations}`],
-				['Project', loop.projectLabel ?? '-'],
-				['Session', loop.sessionId ?? '-'],
-				['Created', loop.createdAt],
-				['Updated', loop.updatedAt],
-			];
-
-			if (loop.lastError) {
-				details.push(['Last Error', tui.colorError(loop.lastError)]);
-			}
-
-			for (const [label, value] of details) {
-				console.log(`  ${tui.muted(label + ':')} ${value}`);
-			}
-
-			console.log();
-			console.log(tui.muted('Task:'));
-			console.log(`  ${loop.prompt}`);
-			console.log();
-		}
-
-		return {
-			found: true,
-			loop: {
-				loopId: loop.loopId,
-				status: loop.status,
-				iteration: loop.iteration,
-				maxIterations: loop.maxIterations,
-				prompt: loop.prompt,
-				projectLabel: loop.projectLabel,
-				sessionId: loop.sessionId,
-				createdAt: loop.createdAt,
-				updatedAt: loop.updatedAt,
-				lastError: loop.lastError,
-			},
-		};
-	},
-});
-
-function formatStatus(status: string): string {
-	switch (status) {
-		case 'running':
-			return tui.colorSuccess('● running');
-		case 'paused':
-			return tui.colorWarning('⏸ paused');
-		case 'completed':
-			return tui.colorSuccess('✓ completed');
-		case 'failed':
-			return tui.colorError('✗ failed');
-		case 'cancelled':
-			return tui.muted('○ cancelled');
-		default:
-			return status;
-	}
-}
-
-export default statusSubcommand;

package/src/cmd/ai/cadence/stop.ts

@@ -1,124 +0,0 @@
-import { z } from 'zod';
-import { createCommand } from '../../../types';
-import * as tui from '../../../tui';
-import {
-	createCadenceKVAdapter,
-	CADENCE_NAMESPACE,
-	getLoopStateKey,
-	parseLoopState,
-	type CadenceLoop,
-} from './util';
-import { getCommand } from '../../../command-prefix';
-
-const CadenceStopResponseSchema = z.object({
-	success: z.boolean(),
-	loopId: z.string(),
-	previousStatus: z.string().optional(),
-	newStatus: z.string().optional(),
-	message: z.string(),
-});
-
-export const stopSubcommand = createCommand({
-	name: 'stop',
-	aliases: ['cancel'],
-	description: 'Stop and cancel a Cadence loop',
-	tags: ['mutating', 'updates-resource', 'fast', 'requires-auth'],
-	requires: { auth: true },
-	examples: [
-		{ command: getCommand('cadence stop lp_auth_impl'), description: 'Stop and cancel a loop' },
-	],
-	schema: {
-		args: z.object({
-			loopId: z.string().min(1).describe('The loop ID to stop'),
-		}),
-		response: CadenceStopResponseSchema,
-	},
-
-	async handler(ctx) {
-		const { args, options } = ctx;
-		const kv = await createCadenceKVAdapter(ctx);
-
-		const key = getLoopStateKey(args.loopId);
-		const result = await kv.get(CADENCE_NAMESPACE, key);
-
-		if (!result.exists || !result.data) {
-			if (!options.json) {
-				tui.error(`Loop ${args.loopId} not found.`);
-			}
-			return {
-				success: false,
-				loopId: args.loopId,
-				message: 'Loop not found',
-			};
-		}
-
-		let data: unknown;
-		if (typeof result.data === 'string') {
-			try {
-				data = JSON.parse(result.data);
-			} catch {
-				if (!options.json) {
-					tui.error(`Failed to parse loop state for ${args.loopId}`);
-				}
-				return {
-					success: false,
-					loopId: args.loopId,
-					message: 'Failed to parse loop state',
-				};
-			}
-		} else {
-			data = result.data;
-		}
-
-		const loop = parseLoopState(data);
-		if (!loop) {
-			if (!options.json) {
-				tui.error(`Invalid loop state for ${args.loopId}`);
-			}
-			return {
-				success: false,
-				loopId: args.loopId,
-				message: 'Invalid loop state',
-			};
-		}
-
-		const previousStatus = loop.status;
-
-		if (loop.status === 'completed' || loop.status === 'cancelled') {
-			if (!options.json) {
-				tui.warning(`Loop ${args.loopId} is already ${loop.status}`);
-			}
-			return {
-				success: false,
-				loopId: args.loopId,
-				previousStatus,
-				message: `Loop is already ${loop.status}`,
-			};
-		}
-
-		// Update status to cancelled
-		const updatedLoop: CadenceLoop = {
-			...loop,
-			status: 'cancelled',
-			updatedAt: new Date().toISOString(),
-		};
-
-		await kv.set(CADENCE_NAMESPACE, key, JSON.stringify(updatedLoop), {
-			contentType: 'application/json',
-		});
-
-		if (!options.json) {
-			tui.success(`Stopped loop ${args.loopId}`);
-		}
-
-		return {
-			success: true,
-			loopId: args.loopId,
-			previousStatus,
-			newStatus: 'cancelled',
-			message: 'Loop cancelled successfully',
-		};
-	},
-});
-
-export default stopSubcommand;

package/src/cmd/ai/cadence/util.ts

@@ -1,86 +0,0 @@
-import { KeyValueStorageService, type Logger } from '@agentuity/core';
-import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
-import { getDefaultRegion } from '../../../config';
-import type { AuthData, Config } from '../../../types';
-
-/** KV namespace for Cadence loop state */
-export const CADENCE_NAMESPACE = 'agentuity-opencode-tasks';
-
-/** Prefix for loop state keys */
-export const LOOP_KEY_PREFIX = 'loop:';
-
-export interface CadenceLoop {
-	loopId: string;
-	parentId?: string;
-	projectLabel?: string;
-	sessionId?: string;
-	status: 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
-	iteration: number;
-	maxIterations: number;
-	prompt: string;
-	createdAt: string;
-	updatedAt: string;
-	lastError?: string;
-	sandbox?: {
-		mode: 'off' | 'per_iteration' | 'persistent';
-		sandboxId?: string;
-	};
-}
-
-export interface CadenceContext {
-	logger: Logger;
-	config: Config | null;
-	auth: AuthData;
-	project?: { region: string };
-}
-
-/**
- * Creates a KV storage service for Cadence operations.
- */
-export async function createCadenceKVAdapter(ctx: CadenceContext): Promise<KeyValueStorageService> {
-	const adapter = createServerFetchAdapter(
-		{
-			headers: {
-				Authorization: `Bearer ${ctx.auth.apiKey}`,
-			},
-		},
-		ctx.logger
-	);
-
-	const region = ctx.project?.region || (await getDefaultRegion(ctx.config?.name, ctx.config));
-	const urls = getServiceUrls(region);
-	const baseUrl = urls.catalyst;
-	return new KeyValueStorageService(baseUrl, adapter);
-}
-
-/**
- * Gets the state key for a loop.
- */
-export function getLoopStateKey(loopId: string): string {
-	return `${LOOP_KEY_PREFIX}${loopId}:state`;
-}
-
-/**
- * Parses a loop state from KV storage.
- */
-export function parseLoopState(data: unknown): CadenceLoop | null {
-	if (!data || typeof data !== 'object') return null;
-
-	const loop = data as Record<string, unknown>;
-	if (!loop.loopId || !loop.status || !loop.prompt) return null;
-
-	return {
-		loopId: String(loop.loopId),
-		parentId: loop.parentId ? String(loop.parentId) : undefined,
-		projectLabel: loop.projectLabel ? String(loop.projectLabel) : undefined,
-		sessionId: loop.sessionId ? String(loop.sessionId) : undefined,
-		status: loop.status as CadenceLoop['status'],
-		iteration: Number(loop.iteration) || 1,
-		maxIterations: Number(loop.maxIterations) || 50,
-		prompt: String(loop.prompt),
-		createdAt: String(loop.createdAt),
-		updatedAt: String(loop.updatedAt),
-		lastError: loop.lastError ? String(loop.lastError) : undefined,
-		sandbox: loop.sandbox as CadenceLoop['sandbox'],
-	};
-}