pikiloop 0.4.0

package/dist/cli/setup-wizard.js

@@ -0,0 +1,235 @@
+/**
+ * Interactive terminal setup wizard.
+ */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { buildSetupGuide, collectSetupState } from './onboarding.js';
+import { getUserConfigPath, saveUserConfig } from '../core/config/user-config.js';
+import { VALIDATION_TIMEOUTS } from '../core/constants.js';
+function createTerminalIO() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+        ask(prompt) {
+            return rl.question(prompt);
+        },
+        write(text) {
+            process.stdout.write(text);
+        },
+        runCommand(command, args = []) {
+            return new Promise(resolve => {
+                const child = spawn(command, args, {
+                    stdio: 'inherit',
+                    env: process.env,
+                });
+                child.on('exit', code => resolve(code ?? 1));
+                child.on('error', () => resolve(1));
+            });
+        },
+        close() {
+            void rl.close();
+        },
+    };
+}
+function parseChoice(raw) {
+    return String(raw || '').trim().toLowerCase();
+}
+async function askYesNo(io, prompt, def) {
+    const suffix = def ? ' [Y/n] ' : ' [y/N] ';
+    for (;;) {
+        const answer = parseChoice(await io.ask(`${prompt}${suffix}`));
+        if (!answer)
+            return def;
+        if (['y', 'yes'].includes(answer))
+            return true;
+        if (['n', 'no'].includes(answer))
+            return false;
+        io.write('Please answer y or n.\n');
+    }
+}
+async function askAgentChoice(io, installed) {
+    io.write('Choose your local coding agent:\n');
+    io.write(`  1. Codex${installed.some(a => a.agent === 'codex' && a.installed) ? ' (installed)' : ''}\n`);
+    io.write(`  2. Claude Code${installed.some(a => a.agent === 'claude' && a.installed) ? ' (installed)' : ''}\n`);
+    io.write('  q. Quit setup\n');
+    for (;;) {
+        const answer = parseChoice(await io.ask('Selection [1/2/q]: '));
+        if (answer === '1' || answer === 'codex')
+            return 'codex';
+        if (answer === '2' || answer === 'claude')
+            return 'claude';
+        if (answer === 'q' || answer === 'quit')
+            return null;
+        io.write('Please choose 1, 2, or q.\n');
+    }
+}
+function preferredInstalledAgent(agents) {
+    if (agents.some(agent => agent.agent === 'codex' && agent.installed))
+        return 'codex';
+    if (agents.some(agent => agent.agent === 'claude' && agent.installed))
+        return 'claude';
+    return null;
+}
+function parseAgent(value) {
+    return value === 'claude' || value === 'codex' ? value : null;
+}
+function title(label) {
+    return `\n${label}\n${'-'.repeat(label.length)}\n`;
+}
+export async function validateTelegramToken(token) {
+    const value = String(token || '').trim();
+    if (!value)
+        return { ok: false, bot: null, error: 'The token was empty.' };
+    try {
+        const resp = await fetch(`https://api.telegram.org/bot${value}/getMe`, {
+            method: 'POST',
+            signal: AbortSignal.timeout(VALIDATION_TIMEOUTS.telegramToken),
+        });
+        const raw = await resp.text();
+        let parsed = null;
+        try {
+            parsed = raw ? JSON.parse(raw) : null;
+        }
+        catch {
+            return { ok: false, bot: null, error: `Telegram returned invalid JSON (${resp.status}).` };
+        }
+        if (!resp.ok || parsed?.ok !== true || !parsed?.result) {
+            const detail = typeof parsed?.description === 'string' ? parsed.description : `HTTP ${resp.status}`;
+            return { ok: false, bot: null, error: `Telegram rejected this token: ${detail}` };
+        }
+        return {
+            ok: true,
+            bot: {
+                id: parsed.result.id,
+                username: parsed.result.username || null,
+                displayName: parsed.result.first_name || null,
+            },
+            error: null,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err ?? 'unknown error');
+        return { ok: false, bot: null, error: `Failed to reach Telegram: ${msg}` };
+    }
+}
+export async function runSetupWizard(options) {
+    const io = options.io || createTerminalIO();
+    const validate = options.validateTelegramToken || validateTelegramToken;
+    const persistConfig = options.persistConfig || saveUserConfig;
+    let state = options.initialState;
+    let selectedAgent = parseAgent(options.argsAgent);
+    let token = String(options.currentToken || '').trim() || null;
+    let tokenCheck = null;
+    let configPath = null;
+    const refreshState = () => {
+        state = collectSetupState({
+            agents: options.listAgents(),
+            channel: options.channel,
+            tokenProvided: !!token,
+        });
+        return state;
+    };
+    try {
+        io.write(title(`pikiloop v${options.version} setup`));
+        if (options.channel !== 'telegram') {
+            io.write(buildSetupGuide(state, options.version));
+            io.write('\nInteractive setup is currently only available for Telegram.\n');
+            return { completed: false, token, agent: null, configPath: null, tokenCheck: null };
+        }
+        io.write('This wizard will help you install or verify a local agent, validate your Telegram bot token, and optionally save the setup for next time.\n');
+        refreshState();
+        io.write(title('Step 1: Local agent'));
+        if (!selectedAgent) {
+            const installedAgent = preferredInstalledAgent(state.agents);
+            if (state.agents.filter(agent => agent.installed).length > 1) {
+                selectedAgent = await askAgentChoice(io, state.agents);
+            }
+            else {
+                selectedAgent = installedAgent || await askAgentChoice(io, state.agents);
+            }
+        }
+        if (!selectedAgent) {
+            io.write('Setup cancelled.\n');
+            return { completed: false, token, agent: null, configPath: null, tokenCheck: null };
+        }
+        let selectedState = refreshState().agents.find(agent => agent.agent === selectedAgent) || null;
+        if (!selectedState?.installed) {
+            io.write(`${selectedState?.label || selectedAgent} is not installed.\n`);
+            const installNow = await askYesNo(io, `Install ${selectedAgent === 'claude' ? 'Claude Code' : 'Codex'} now?`, true);
+            if (!installNow) {
+                io.write('Setup cancelled. Install the agent first, then run `npx pikiloop@latest` again.\n');
+                return { completed: false, token, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+            io.write(`Running: ${selectedState?.installCommand || `npm install -g ${selectedAgent}`}\n`);
+            const exitCode = await io.runCommand('npm', ['install', '-g', selectedAgent === 'claude' ? '@anthropic-ai/claude-code' : '@openai/codex']);
+            selectedState = refreshState().agents.find(agent => agent.agent === selectedAgent) || null;
+            if (exitCode !== 0 || !selectedState?.installed) {
+                io.write(`Install did not complete successfully. You can try manually: ${selectedState?.installCommand || ''}\n`);
+                return { completed: false, token, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+        }
+        io.write(`Using ${selectedState.label}.\n`);
+        io.write(title('Step 2: Telegram bot token'));
+        if (token) {
+            tokenCheck = await validate(token);
+            if (tokenCheck.ok) {
+                io.write(`Existing token looks valid for @${tokenCheck.bot?.username || 'unknown_bot'}.\n`);
+            }
+            else {
+                io.write(`The existing token could not be verified: ${tokenCheck.error}\n`);
+                token = null;
+            }
+        }
+        if (!token) {
+            io.write('Get a bot token from Telegram first:\n');
+            io.write('  1. Open Telegram and search for @BotFather\n');
+            io.write('  2. Send /newbot\n');
+            io.write('  3. Choose a display name and a username\n');
+            io.write('  4. Paste the token here\n');
+        }
+        while (!token) {
+            const answer = String(await io.ask('Paste your Telegram bot token (or type q to quit): ')).trim();
+            if (!answer)
+                continue;
+            if (parseChoice(answer) === 'q') {
+                io.write('Setup cancelled.\n');
+                return { completed: false, token: null, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+            const check = await validate(answer);
+            if (!check.ok) {
+                io.write(`${check.error}\n`);
+                continue;
+            }
+            token = answer;
+            tokenCheck = check;
+            io.write(`Telegram bot verified: @${check.bot?.username || 'unknown_bot'}${check.bot?.displayName ? ` (${check.bot.displayName})` : ''}\n`);
+        }
+        io.write(title('Step 3: Save setup'));
+        const configFile = getUserConfigPath();
+        const saveIt = await askYesNo(io, `Save this setup to ${configFile}?`, true);
+        if (saveIt) {
+            configPath = persistConfig({
+                channel: 'telegram',
+                defaultAgent: selectedAgent,
+                telegramBotToken: token,
+            });
+            io.write(`Saved config to ${configPath}\n`);
+        }
+        else {
+            io.write('Skipping config save. This run will still start now, but you may need to provide the token again next time.\n');
+        }
+        io.write(title('Ready'));
+        io.write(`Agent: ${selectedAgent}\n`);
+        io.write(`Telegram bot: @${tokenCheck?.bot?.username || 'unknown_bot'}\n`);
+        io.write('Starting pikiloop now...\n');
+        return {
+            completed: true,
+            token,
+            agent: selectedAgent,
+            configPath,
+            tokenCheck,
+        };
+    }
+    finally {
+        io.close();
+    }
+}

package/dist/core/config/runtime-config.js

@@ -0,0 +1,201 @@
+/**
+ * Runtime resolution of agent model and effort preferences.
+ */
+import { normalizeClaudeModelId } from '../../agent/index.js';
+export const DEFAULT_AGENT_MODELS = {
+    claude: 'claude-opus-4-8',
+    codex: 'gpt-5.5',
+    gemini: 'gemini-3.1-pro-preview',
+    hermes: 'anthropic/claude-sonnet-4',
+};
+export const DEFAULT_AGENT_EFFORTS = {
+    claude: 'high',
+    codex: 'xhigh',
+    gemini: 'high',
+    hermes: 'medium',
+};
+function trimmed(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/** Parse a boolean-ish string (env var / loose config). Empty → null (unset). */
+function parseBoolish(value) {
+    const v = value.trim().toLowerCase();
+    if (!v)
+        return null;
+    if (v === '1' || v === 'true' || v === 'on' || v === 'yes' || v === 'enabled')
+        return true;
+    if (v === '0' || v === 'false' || v === 'off' || v === 'no' || v === 'disabled')
+        return false;
+    return null;
+}
+export function agentModelEnv(agent, env = process.env) {
+    switch (agent) {
+        case 'claude': return trimmed(env.CLAUDE_MODEL);
+        case 'codex': return trimmed(env.CODEX_MODEL);
+        case 'gemini': return trimmed(env.GEMINI_MODEL);
+        case 'hermes': return trimmed(env.HERMES_MODEL);
+    }
+    return '';
+}
+export function agentEffortEnv(agent, env = process.env) {
+    switch (agent) {
+        case 'claude': return trimmed(env.CLAUDE_REASONING_EFFORT).toLowerCase();
+        case 'codex': return trimmed(env.CODEX_REASONING_EFFORT).toLowerCase();
+        case 'gemini': return trimmed(env.GEMINI_REASONING_EFFORT).toLowerCase();
+        case 'hermes': return trimmed(env.HERMES_REASONING_EFFORT).toLowerCase();
+    }
+    return '';
+}
+export function resolveAgentModel(config, agent) {
+    let value = '';
+    switch (agent) {
+        case 'claude':
+            value = trimmed(config.claudeModel || agentModelEnv('claude') || DEFAULT_AGENT_MODELS.claude);
+            return normalizeClaudeModelId(value);
+        case 'codex':
+            value = trimmed(config.codexModel || agentModelEnv('codex') || DEFAULT_AGENT_MODELS.codex);
+            return value || DEFAULT_AGENT_MODELS.codex;
+        case 'gemini':
+            value = trimmed(config.geminiModel || agentModelEnv('gemini') || DEFAULT_AGENT_MODELS.gemini);
+            return value || DEFAULT_AGENT_MODELS.gemini;
+        case 'hermes':
+            value = trimmed(config.hermesModel || agentModelEnv('hermes') || DEFAULT_AGENT_MODELS.hermes);
+            return value || DEFAULT_AGENT_MODELS.hermes;
+    }
+    return '';
+}
+export function resolveAgentEffort(config, agent) {
+    switch (agent) {
+        case 'claude': {
+            const value = trimmed(config.claudeReasoningEffort || agentEffortEnv('claude') || DEFAULT_AGENT_EFFORTS.claude).toLowerCase();
+            return value || DEFAULT_AGENT_EFFORTS.claude || null;
+        }
+        case 'codex': {
+            const value = trimmed(config.codexReasoningEffort || agentEffortEnv('codex') || DEFAULT_AGENT_EFFORTS.codex).toLowerCase();
+            return value || DEFAULT_AGENT_EFFORTS.codex || null;
+        }
+        case 'gemini': {
+            const value = trimmed(config.geminiReasoningEffort || agentEffortEnv('gemini') || DEFAULT_AGENT_EFFORTS.gemini).toLowerCase();
+            return value || DEFAULT_AGENT_EFFORTS.gemini || null;
+        }
+        case 'hermes': {
+            const value = trimmed(config.hermesReasoningEffort || agentEffortEnv('hermes') || DEFAULT_AGENT_EFFORTS.hermes).toLowerCase();
+            return value || DEFAULT_AGENT_EFFORTS.hermes || null;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Workflow (multi-agent orchestration) toggle
+//
+// Orthogonal to effort: effort tunes how deeply a *single* agent reasons;
+// workflow grants the agent permission to author + run multi-agent Workflow
+// orchestrations (fan-out / pipeline / verify). Only agents whose driver
+// advertises `capabilities.workflow` honor it (claude today). Default OFF —
+// the claude driver hard-disables the Workflow tool unless this is true, so a
+// bare "workflow" keyword can never auto-spawn a fleet of sub-agents under the
+// bypassPermissions mode pikiloop runs by default.
+// ---------------------------------------------------------------------------
+export function agentWorkflowEnv(agent, env = process.env) {
+    switch (agent) {
+        case 'claude': return trimmed(env.CLAUDE_WORKFLOW);
+    }
+    return '';
+}
+export function resolveAgentWorkflowEnabled(config, agent) {
+    switch (agent) {
+        case 'claude': {
+            const raw = config.claudeWorkflowEnabled;
+            if (typeof raw === 'boolean')
+                return raw;
+            const fromEnv = parseBoolish(agentWorkflowEnv('claude'));
+            return fromEnv ?? false;
+        }
+    }
+    return false;
+}
+export function setAgentWorkflowEnv(agent, value, env = process.env) {
+    switch (agent) {
+        case 'claude':
+            env.CLAUDE_WORKFLOW = value ? '1' : '0';
+            break;
+    }
+}
+export const DEFAULT_CLAUDE_ACCESS_MODE = 'subscription';
+/**
+ * Access mode implied by env, or null when neither var has an opinion.
+ * PIKILOOP_CLAUDE_PRINT takes precedence over the legacy PIKILOOP_CLAUDE_TUI so
+ * a freshly-written print var resolves a stale tui var (setClaudeAccessModeEnv
+ * relies on this). Mirrors isClaudePrintModeForced() in the claude driver.
+ */
+export function claudeAccessModeEnv(env = process.env) {
+    const print = parseBoolish(trimmed(env.PIKILOOP_CLAUDE_PRINT));
+    if (print != null)
+        return print ? 'api' : 'subscription';
+    const tui = parseBoolish(trimmed(env.PIKILOOP_CLAUDE_TUI));
+    if (tui != null)
+        return tui ? 'subscription' : 'api';
+    return null;
+}
+export function resolveClaudeAccessMode(config) {
+    const raw = config.claudeAccessMode;
+    if (raw === 'subscription' || raw === 'api')
+        return raw;
+    return claudeAccessModeEnv() ?? DEFAULT_CLAUDE_ACCESS_MODE;
+}
+/** Mirror the choice into PIKILOOP_CLAUDE_PRINT so any env-only fallback path
+ *  (and tooling that inspects the env) agrees with the persisted config. */
+export function setClaudeAccessModeEnv(value, env = process.env) {
+    env.PIKILOOP_CLAUDE_PRINT = value === 'api' ? '1' : '0';
+}
+export function setAgentModelEnv(agent, value, env = process.env) {
+    switch (agent) {
+        case 'claude':
+            env.CLAUDE_MODEL = value;
+            break;
+        case 'codex':
+            env.CODEX_MODEL = value;
+            break;
+        case 'gemini':
+            env.GEMINI_MODEL = value;
+            break;
+        case 'hermes':
+            env.HERMES_MODEL = value;
+            break;
+    }
+}
+export function setAgentEffortEnv(agent, value, env = process.env) {
+    switch (agent) {
+        case 'claude':
+            env.CLAUDE_REASONING_EFFORT = value;
+            break;
+        case 'codex':
+            env.CODEX_REASONING_EFFORT = value;
+            break;
+        case 'gemini':
+            env.GEMINI_REASONING_EFFORT = value;
+            break;
+        case 'hermes':
+            env.HERMES_REASONING_EFFORT = value;
+            break;
+    }
+}
+// ---------------------------------------------------------------------------
+// "Ultra" effort rung — the single user-facing knob that folds workflow in
+//
+// Surfaced as the top rung of every effort picker (IM /models + dashboard),
+// "ultra" means "max reasoning depth + permit multi-agent Workflow
+// orchestration" — the same bundle as Claude's native `ultracode` mode. It is
+// NOT a real --effort value (the CLI hard-rejects anything outside
+// low|medium|high|xhigh|max), so every effort-write path decomposes it into a
+// concrete effort plus the orthogonal workflow flag via this single helper.
+// Because the rungs are mutually exclusive, picking any concrete level clears
+// the orchestration opt-in. See Bot.switchEffortForChat for the IM mirror.
+// ---------------------------------------------------------------------------
+export const ULTRA_EFFORT = 'ultra';
+export function decomposeEffortSelection(raw) {
+    const value = trimmed(raw).toLowerCase();
+    if (value === ULTRA_EFFORT)
+        return { effort: 'max', workflow: true };
+    return { effort: value, workflow: false };
+}