@agentuity/opencode 0.1.15

package/src/services/auth.ts

@@ -0,0 +1,88 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { YAML } from 'bun';
+
+export interface CloudContext {
+	authenticated: boolean;
+	orgId?: string;
+	userId?: string;
+}
+
+interface ConfigFile {
+	name?: string;
+	auth?: {
+		api_key?: string;
+		user_id?: string;
+		expires?: number;
+	};
+	preferences?: {
+		orgId?: string;
+	};
+	coder?: {
+		org?: string;
+	};
+}
+
+const AGENTUITY_CONFIG_DIR = join(homedir(), '.config', 'agentuity');
+const DEFAULT_PROFILE = 'production.yaml';
+
+async function getProfilePath(): Promise<string> {
+	const profileFile = Bun.file(join(AGENTUITY_CONFIG_DIR, 'profile'));
+
+	if (await profileFile.exists()) {
+		const savedPath = (await profileFile.text()).trim();
+		const savedFile = Bun.file(savedPath);
+		if (await savedFile.exists()) {
+			return savedPath;
+		}
+	}
+
+	return join(AGENTUITY_CONFIG_DIR, DEFAULT_PROFILE);
+}
+
+export async function getCloudContext(): Promise<CloudContext> {
+	try {
+		const configPath = await getProfilePath();
+		const configFile = Bun.file(configPath);
+
+		if (!(await configFile.exists())) {
+			return { authenticated: false };
+		}
+
+		const content = await configFile.text();
+		const config = YAML.parse(content) as ConfigFile;
+
+		const hasAuth = Boolean(config.auth?.api_key);
+		const orgId = config.preferences?.orgId;
+
+		return {
+			authenticated: hasAuth,
+			orgId,
+			userId: config.auth?.user_id,
+		};
+	} catch {
+		return { authenticated: false };
+	}
+}
+
+export async function checkAuth(): Promise<
+	{ ok: true; context: CloudContext } | { ok: false; error: string }
+> {
+	const context = await getCloudContext();
+
+	if (!context.authenticated) {
+		return {
+			ok: false,
+			error: 'Not authenticated. Run `agentuity auth login` first.',
+		};
+	}
+
+	if (!context.orgId) {
+		return {
+			ok: false,
+			error: 'No organization selected. Run `agentuity cloud org select` first.',
+		};
+	}
+
+	return { ok: true, context };
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export { checkAuth, getCloudContext, type CloudContext } from './auth';

package/src/tools/delegate.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { AgentRole } from '../types';
+
+// Schema for the delegate tool
+export const DelegateArgsSchema = z.object({
+	agent: z
+		.enum(['scout', 'builder', 'reviewer', 'memory', 'expert'])
+		.describe('The agent to delegate to'),
+	task: z.string().describe('Clear description of the task to delegate'),
+	context: z.string().optional().describe('Additional context from previous tasks'),
+	waitForResult: z
+		.boolean()
+		.default(true)
+		.describe('Whether to wait for the result before continuing'),
+});
+
+export type DelegateArgs = z.infer<typeof DelegateArgsSchema>;
+
+// Agent display names for @mentions
+const AGENT_MENTIONS: Record<AgentRole, string> = {
+	lead: '@Agentuity Coder Lead',
+	scout: '@Agentuity Coder Scout',
+	builder: '@Agentuity Coder Builder',
+	reviewer: '@Agentuity Coder Reviewer',
+	memory: '@Agentuity Coder Memory',
+	expert: '@Agentuity Coder Expert',
+};
+
+export const delegateTool = {
+	name: 'coder_delegate',
+	description: `Delegate a task to a specialized Agentuity Coder agent.
+
+Use this to:
+- Scout: Explore codebase, find patterns, research documentation
+- Builder: Implement features, write code, run tests
+- Reviewer: Review changes, catch issues, apply fixes  
+- Memory: Store context, remember decisions across sessions
+- Expert: Get help with Agentuity CLI and cloud services
+
+The task will be executed by the specified agent and the result returned.`,
+
+	args: DelegateArgsSchema,
+
+	async execute(args: DelegateArgs, _context: unknown): Promise<{ output: string }> {
+		const mention = AGENT_MENTIONS[args.agent as AgentRole];
+
+		// Build the delegation prompt
+		let prompt = `${mention}\n\n## Task\n${args.task}`;
+
+		if (args.context) {
+			prompt = `${mention}\n\n## Context\n${args.context}\n\n## Task\n${args.task}`;
+		}
+
+		// In Open Code, this would trigger the Task tool with the appropriate agent
+		// For now, return the formatted prompt that Lead should use
+		return {
+			output: `To delegate this task, use the Task tool with this prompt:\n\n${prompt}\n\nThe ${args.agent} agent will handle this task.`,
+		};
+	},
+};
+
+export default delegateTool;

package/src/tools/index.ts

@@ -0,0 +1 @@
+export { delegateTool, DelegateArgsSchema, type DelegateArgs } from './delegate';

package/src/types.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+
+export const AgentRoleSchema = z.enum(['lead', 'scout', 'builder', 'reviewer', 'memory', 'expert']);
+export type AgentRole = z.infer<typeof AgentRoleSchema>;
+
+export const TaskStatusSchema = z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+export const OrchestrationPatternSchema = z.enum(['single', 'fanout', 'pipeline']);
+export type OrchestrationPattern = z.infer<typeof OrchestrationPatternSchema>;
+
+export interface AgentConfig {
+	/** Agent description - explains what it does and when to use it */
+	description: string;
+	/** Model ID in provider/model-id format */
+	model: string;
+	/** System prompt content (not a file path) */
+	prompt: string;
+	/** Agent mode: 'primary', 'subagent', or 'all' (default) */
+	mode?: 'primary' | 'subagent' | 'all';
+	/** Tool configuration */
+	tools?: Record<string, boolean>;
+	/** Model variant for thinking/reasoning (e.g., 'high', 'max' for Anthropic) */
+	variant?: string;
+	/** Temperature for response creativity (0.0-2.0) */
+	temperature?: number;
+	/** Maximum agentic steps before forcing text response */
+	maxSteps?: number;
+}
+
+export interface AgentContext {
+	projectRoot: string;
+	orgId?: string;
+	sessionId?: string;
+	taskId?: string;
+}
+
+export interface CoderTask {
+	id: string;
+	title: string;
+	description?: string;
+	status: TaskStatus;
+	createdAt: Date;
+	updatedAt: Date;
+	assignedTo?: AgentRole;
+	parentTaskId?: string;
+	result?: string;
+	error?: string;
+}
+
+export interface CoderConfig {
+	org?: string;
+	agents?: Partial<Record<AgentRole, AgentModelConfig>>;
+	disabledMcps?: string[];
+	/** CLI command patterns to block for security (e.g., 'cloud secrets', 'auth token') */
+	blockedCommands?: string[];
+}
+
+export interface AgentModelConfig {
+	model?: string;
+	temperature?: number;
+}
+
+export const CoderConfigSchema = z.object({
+	org: z.string().optional(),
+	agents: z
+		.record(
+			AgentRoleSchema,
+			z.object({
+				model: z.string().optional(),
+				temperature: z.number().min(0).max(2).optional(),
+			})
+		)
+		.optional(),
+	disabledMcps: z.array(z.string()).optional(),
+	blockedCommands: z.array(z.string()).optional(),
+});
+
+export interface McpConfig {
+	name: string;
+	type: 'remote';
+	url: string;
+	enabled: boolean;
+	headers?: Record<string, string>;
+}
+
+export interface PluginClient {
+	app: {
+		log: (options: {
+			body: { service: string; level: string; message: string; extra?: unknown };
+		}) => void;
+	};
+	tui?: {
+		showToast?: (options: {
+			body: { message: string };
+		}) => void;
+	};
+}
+
+export interface PluginContext {
+	directory: string;
+	client: PluginClient;
+}
+
+export interface PluginHooks {
+	agents?: Record<string, AgentConfig>;
+	tool?: Record<string, unknown>; // Open Code tool format (created via tool() helper)
+	config?: (config: Record<string, unknown>) => Promise<void>;
+	'chat.message'?: (input: unknown, output: unknown) => Promise<void>;
+	'chat.params'?: (input: unknown, output: unknown) => Promise<void>;
+	'tool.execute.before'?: (input: unknown, output: unknown) => Promise<void>;
+	'tool.execute.after'?: (input: unknown, output: unknown) => Promise<void>;
+	event?: (input: unknown) => Promise<void>;
+}
+
+export interface CommandDefinition {
+	name: string;
+	description?: string;
+	template: string;
+	agent?: string;
+	model?: string;
+	argumentHint?: string;
+	/** Force command to run as subagent for context isolation */
+	subtask?: boolean;
+}
+
+export interface ToolDefinition {
+	description: string;
+	args: unknown; // Zod schema or JSON schema
+	execute: (args: unknown, context: unknown) => Promise<unknown>;
+}