awel 0.1.0

package/dist/cli/logger.js

@@ -0,0 +1,40 @@
+// ─── Prefixed Logger ─────────────────────────────────────────
+// Colored [awel] / [next] prefixes for terminal output so the
+// user can distinguish Awel's messages from the Next.js app's.
+import { createInterface } from 'readline';
+// ANSI 256-color helpers — darker shades that stay visible on light backgrounds
+const cyan = (s) => `\x1b[38;5;30m${s}\x1b[39m`;
+const magenta = (s) => `\x1b[38;5;127m${s}\x1b[39m`;
+const bold = (s) => `\x1b[1m${s}\x1b[22m`;
+const AWEL_PREFIX = bold(cyan('[awel]'));
+const NEXT_PREFIX = bold(magenta('[next]'));
+function prefixedWriter(prefix, stream) {
+    return (...args) => {
+        const message = args.map(String).join(' ');
+        for (const line of message.split('\n')) {
+            stream.write(`${prefix} ${line}\n`);
+        }
+    };
+}
+export const awel = {
+    log: prefixedWriter(AWEL_PREFIX, process.stdout),
+    error: prefixedWriter(AWEL_PREFIX, process.stderr),
+};
+/**
+ * Pipe a child process's stdout/stderr line-by-line, prefixing
+ * each line with the magenta [next] tag.
+ */
+export function pipeChildOutput(child) {
+    if (child.stdout) {
+        const rl = createInterface({ input: child.stdout });
+        rl.on('line', (line) => {
+            process.stdout.write(`${NEXT_PREFIX} ${line}\n`);
+        });
+    }
+    if (child.stderr) {
+        const rl = createInterface({ input: child.stderr });
+        rl.on('line', (line) => {
+            process.stderr.write(`${NEXT_PREFIX} ${line}\n`);
+        });
+    }
+}

package/dist/cli/plan-store.d.ts

@@ -0,0 +1,14 @@
+export interface StoredPlan {
+    planId: string;
+    plan: {
+        title: string;
+        content: string;
+    };
+    originalPrompt: string;
+    modelId: string;
+    approved: boolean;
+}
+export declare function storePlan(plan: StoredPlan): void;
+export declare function getActivePlan(): StoredPlan | null;
+export declare function approvePlan(): boolean;
+export declare function clearActivePlan(): void;

package/dist/cli/plan-store.js

@@ -0,0 +1,18 @@
+// ─── Plan Store ──────────────────────────────────────────────
+// Module-level singleton storing the active plan proposed by the agent.
+let activePlan = null;
+export function storePlan(plan) {
+    activePlan = plan;
+}
+export function getActivePlan() {
+    return activePlan;
+}
+export function approvePlan() {
+    if (!activePlan)
+        return false;
+    activePlan.approved = true;
+    return true;
+}
+export function clearActivePlan() {
+    activePlan = null;
+}

package/dist/cli/providers/registry.d.ts

@@ -0,0 +1,17 @@
+import type { StreamProvider, ModelDefinition } from './types.js';
+export declare const PROVIDER_ENV_KEYS: Record<string, string>;
+export declare function resolveProvider(modelId: string): {
+    provider: StreamProvider;
+    modelProvider: string;
+};
+export interface ModelWithAvailability extends ModelDefinition {
+    available: boolean;
+    unavailableReason?: string;
+}
+/**
+ * Returns the model catalog enriched with availability info.
+ * Each entry includes `available: boolean` and an optional `unavailableReason`.
+ * The `claude-code` provider checks for the `claude` CLI binary instead of an env var.
+ * Providers without a known env key mapping default to available.
+ */
+export declare function getModelCatalogWithAvailability(): ModelWithAvailability[];

package/dist/cli/providers/registry.js

@@ -0,0 +1,112 @@
+import { execSync } from 'node:child_process';
+import { createVercelProvider } from './vercel.js';
+// ─── Model Catalog ───────────────────────────────────────────
+const MODEL_CATALOG = [
+    // Claude Code models (via ai-sdk-provider-claude-code — uses Claude CLI binary, no API key)
+    { id: 'sonnet', label: 'Claude Sonnet', provider: 'claude-code' },
+    { id: 'opus', label: 'Claude Opus', provider: 'claude-code' },
+    { id: 'haiku', label: 'Claude Haiku', provider: 'claude-code' },
+    // Anthropic API models (@ai-sdk/anthropic — uses ANTHROPIC_API_KEY)
+    { id: 'claude-sonnet-4-5', label: 'Claude Sonnet 4.5', provider: 'anthropic' },
+    { id: 'claude-opus-4-5', label: 'Claude Opus 4.5', provider: 'anthropic' },
+    { id: 'claude-haiku-4-5', label: 'Claude Haiku 4.5', provider: 'anthropic' },
+    // OpenAI models (@ai-sdk/openai)
+    { id: 'gpt-5.2-codex', label: 'GPT-5.2 Codex', provider: 'openai' },
+    { id: 'gpt-5.1-codex', label: 'GPT-5.1 Codex', provider: 'openai' },
+    { id: 'gpt-5.2-pro', label: 'GPT-5.2 Pro', provider: 'openai' },
+    { id: 'gpt-5.2-chat-latest', label: 'GPT-5.2 Chat Latest', provider: 'openai' },
+    { id: 'gpt-5-nano', label: 'GPT-5 Nano', provider: 'openai' },
+    { id: 'gpt-5-mini', label: 'GPT-5 Mini', provider: 'openai' },
+    // Google AI models (@ai-sdk/google)
+    { id: 'gemini-3-pro-preview', label: 'Gemini 3 Pro', provider: 'google-ai' },
+    { id: 'gemini-3-flash-preview', label: 'Gemini 3 Flash', provider: 'google-ai' },
+    { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', provider: 'google-ai' },
+    { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash', provider: 'google-ai' },
+    // Qwen models (qwen-ai-provider — uses DASHSCOPE_API_KEY)
+    { id: 'qwen-max', label: 'Qwen Max', provider: 'qwen' },
+    { id: 'qwen-plus-latest', label: 'Qwen Plus', provider: 'qwen' },
+    // MiniMax models (vercel-minimax-ai-provider — uses MINIMAX_API_KEY)
+    { id: 'MiniMax-M2', label: 'MiniMax M2', provider: 'minimax' },
+    // Vercel AI Gateway — Claude models via gateway (Claude Max / API key)
+    { id: 'anthropic/claude-sonnet-4-5', label: 'Sonnet 4.5 (Gateway)', provider: 'vercel-gateway' },
+    { id: 'anthropic/claude-opus-4-5', label: 'Opus 4.5 (Gateway)', provider: 'vercel-gateway' },
+    { id: 'anthropic/claude-sonnet-4', label: 'Sonnet 4 (Gateway)', provider: 'vercel-gateway' },
+    { id: 'anthropic/claude-opus-4', label: 'Opus 4 (Gateway)', provider: 'vercel-gateway' },
+];
+export const PROVIDER_ENV_KEYS = {
+    // claude-code: uses Claude Code CLI binary, checked separately
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    'google-ai': 'GOOGLE_GENERATIVE_AI_API_KEY',
+    'vercel-gateway': 'AI_GATEWAY_API_KEY',
+    qwen: 'DASHSCOPE_API_KEY',
+    minimax: 'MINIMAX_API_KEY',
+};
+/**
+ * Checks whether the `claude` CLI binary is available in PATH.
+ * Cached after first call since the binary won't appear/disappear mid-session.
+ */
+let _claudeBinaryAvailable = null;
+function isClaudeBinaryAvailable() {
+    if (_claudeBinaryAvailable !== null)
+        return _claudeBinaryAvailable;
+    try {
+        execSync('which claude', { stdio: 'ignore' });
+        _claudeBinaryAvailable = true;
+    }
+    catch {
+        _claudeBinaryAvailable = false;
+    }
+    return _claudeBinaryAvailable;
+}
+// ─── Provider Resolution ─────────────────────────────────────
+export function resolveProvider(modelId) {
+    const model = MODEL_CATALOG.find(m => m.id === modelId);
+    if (!model) {
+        throw new Error(`Unknown model: ${modelId}. Use GET /api/models for available models.`);
+    }
+    let provider;
+    switch (model.provider) {
+        case 'claude-code':
+        case 'anthropic':
+        case 'openai':
+        case 'google-ai':
+        case 'vercel-gateway':
+        case 'qwen':
+        case 'minimax':
+            provider = createVercelProvider(modelId, model.provider);
+            break;
+        default:
+            throw new Error(`No provider implementation for: ${model.provider}`);
+    }
+    return { provider, modelProvider: model.provider };
+}
+/**
+ * Returns the model catalog enriched with availability info.
+ * Each entry includes `available: boolean` and an optional `unavailableReason`.
+ * The `claude-code` provider checks for the `claude` CLI binary instead of an env var.
+ * Providers without a known env key mapping default to available.
+ */
+export function getModelCatalogWithAvailability() {
+    return MODEL_CATALOG.map((model) => {
+        // Claude Code provider: check for the `claude` binary, not an API key
+        if (model.provider === 'claude-code') {
+            const hasBinary = isClaudeBinaryAvailable();
+            return {
+                ...model,
+                available: hasBinary,
+                ...(!hasBinary && { unavailableReason: 'Claude Code CLI not installed' }),
+            };
+        }
+        const envKey = PROVIDER_ENV_KEYS[model.provider];
+        if (!envKey) {
+            return { ...model, available: true };
+        }
+        const hasKey = !!process.env[envKey];
+        return {
+            ...model,
+            available: hasKey,
+            ...(!hasKey && { unavailableReason: `${envKey} not set` }),
+        };
+    });
+}

package/dist/cli/providers/types.d.ts

@@ -0,0 +1,17 @@
+import type { SSEStreamingApi } from 'hono/streaming';
+import type { ModelMessage, AssistantModelMessage, ToolModelMessage } from 'ai';
+export type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+export interface ProviderConfig {
+    projectCwd: string;
+    targetPort: number;
+    /** When aborted, the provider should stop the LLM stream and exit early. */
+    signal?: AbortSignal;
+}
+export interface StreamProvider {
+    streamResponse(stream: SSEStreamingApi, messages: ModelMessage[], config: ProviderConfig): Promise<ResponseMessage[]>;
+}
+export interface ModelDefinition {
+    id: string;
+    label: string;
+    provider: 'claude-code' | 'anthropic' | 'openai' | 'google-ai' | 'vercel-gateway' | 'qwen' | 'minimax';
+}

package/dist/cli/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/providers/vercel.d.ts

@@ -0,0 +1,4 @@
+import type { StreamProvider } from './types.js';
+type VercelProviderType = 'claude-code' | 'anthropic' | 'openai' | 'google-ai' | 'vercel-gateway' | 'qwen' | 'minimax';
+export declare function createVercelProvider(modelId: string, providerType: VercelProviderType): StreamProvider;
+export {};