pikiloop 0.4.0

package/dist/bot/commands.js

@@ -0,0 +1,513 @@
+/**
+ * bot-commands.ts — channel-agnostic command data layer.
+ *
+ * Each function returns structured data objects that any IM renderer can consume.
+ * No rendering, no HTML, no platform-specific formatting.
+ *
+ * Usage from a channel-specific bot (e.g. bot-telegram.ts, bot-feishu.ts):
+ *   const data = await getSessionsPageData(bot, chatId, 0);
+ *   const rendered = renderSessionsPage(data); // channel-specific renderer
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import { fmtTokens, fmtUptime, fmtBytes } from './bot.js';
+import { getProjectSkillPaths, normalizeClaudeModelId, sessionListDisplayTitle, listAllMcpExtensions, listSkills as listAllSkills, } from '../agent/index.js';
+import { getDriver } from '../agent/driver.js';
+import { getActiveProfile, getProvider } from '../model/index.js';
+import { buildWelcomeIntro, buildSkillCommandName, indexSkillsByCommand, SKILL_CMD_PREFIX } from './menu.js';
+import { buildBotMenuState } from './orchestration.js';
+import { summarizePromptForStatus } from './streaming.js';
+import { getSessionStatusForChat } from './session-status.js';
+import { loadWorkspaces } from '../core/config/user-config.js';
+import { VERSION } from '../core/version.js';
+import { readGitStatus } from '../core/git.js';
+export function getStartData(bot, chatId) {
+    const cs = bot.chat(chatId);
+    const intro = buildWelcomeIntro(VERSION);
+    const commands = buildBotMenuState(bot).commands;
+    const res = bot.fetchAgents();
+    const agentDetails = res.agents
+        .filter(a => a.installed)
+        .map(a => ({
+        agent: a.agent,
+        model: bot.modelForAgent(a.agent) || '(default)',
+        effort: bot.effortSelectionForAgent(a.agent),
+    }));
+    return {
+        ...intro,
+        agent: cs.agent,
+        workdir: bot.chatWorkdir(chatId),
+        agentDetails,
+        commands,
+    };
+}
+export function getWorkspacesData(bot, chatId) {
+    const currentWorkdir = path.resolve(bot.chatWorkdir(chatId));
+    const entries = loadWorkspaces();
+    const workspaces = entries
+        .slice()
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+        .map(w => {
+        const resolved = path.resolve(w.path);
+        let exists = false;
+        try {
+            exists = fs.existsSync(resolved) && fs.statSync(resolved).isDirectory();
+        }
+        catch {
+            exists = false;
+        }
+        return {
+            path: resolved,
+            name: w.name || path.basename(resolved),
+            isCurrent: resolved === currentWorkdir,
+            exists,
+        };
+    });
+    return { currentWorkdir, workspaces };
+}
+// ---------------------------------------------------------------------------
+// Goal — channel-agnostic /goal command dispatch
+// ---------------------------------------------------------------------------
+/**
+ * Handle /goal <args> for a chat. Returns a human-readable status line for
+ * the IM renderer to send back. Returns null when there is no active session
+ * for the chat (caller renders its own "pick a session first" message).
+ *
+ * Per-agent routing:
+ *   - codex → native `thread/goal/*` RPC (state machine + budget + pause/resume)
+ *   - claude → native `/goal <condition>` slash command (Stop hook continuation,
+ *              auto-clear on completion, no budget / no pause/resume)
+ *   - others → pikiloop's portable goal.json with continuation injection
+ */
+export async function handleGoalCommand(bot, chatId, rawArgs) {
+    const session = bot.selectedSession(chatId);
+    if (!session || !session.sessionId)
+        return null;
+    const args = rawArgs.trim();
+    const workdir = session.workdir;
+    const agent = session.agent;
+    const sessionId = session.sessionId;
+    if (!args) {
+        const goal = await bot.getSessionGoal(workdir, agent, sessionId);
+        return formatGoalStatusLine(goal, agent);
+    }
+    const lower = args.toLowerCase();
+    try {
+        if (lower === 'pause') {
+            const goal = await bot.pauseSessionGoal(workdir, agent, sessionId);
+            if (!goal)
+                return 'No goal set for this session.';
+            return `Paused goal: ${truncate(goal.objective, 80)}`;
+        }
+        if (lower === 'resume') {
+            const goal = await bot.resumeSessionGoal(workdir, agent, sessionId, { chatId });
+            if (!goal)
+                return 'No goal to resume.';
+            if (goal.status !== 'active')
+                return `Cannot resume goal (status: ${goal.status}).`;
+            return `Resumed goal: ${truncate(goal.objective, 80)}`;
+        }
+        if (lower === 'clear' || lower === 'cancel' || lower === 'stop') {
+            await bot.clearSessionGoal(workdir, agent, sessionId, { chatId });
+            return agent === 'claude'
+                ? 'Submitted `/goal clear` to claude. (Native /goal auto-clears once the condition is met, so this is only needed to stop early.)'
+                : 'Cleared goal.';
+        }
+        const { objective, tokenBudget } = parseObjective(args);
+        if (!objective)
+            return 'Usage: /goal <objective>  (or pause / resume / clear)';
+        if (agent === 'claude' && tokenBudget != null) {
+            return 'Claude native /goal does not support `budget=N` — drop the budget prefix. (Use a codex session if you need a token budget.)';
+        }
+        const goal = await bot.setSessionGoal(workdir, agent, sessionId, {
+            objective,
+            tokenBudget,
+            chatId,
+        });
+        const budgetLabel = goal.tokenBudget != null ? `, budget ${goal.tokenBudget} tokens` : '';
+        if (agent === 'codex') {
+            return [
+                `Goal set (codex native)${budgetLabel}: ${truncate(goal.objective, 120)}`,
+                'Send any message to trigger codex\'s native continuation loop. Each message resumes the thread and codex audits / continues until it marks the goal complete or hits the budget.',
+            ].join('\n');
+        }
+        if (agent === 'claude') {
+            return [
+                `Goal set (claude native): ${truncate(goal.objective, 120)}`,
+                'Claude\'s in-process Stop hook keeps working until a Haiku judge confirms the condition is met, then auto-clears. Send `/goal clear` to stop early; `/goal` to inspect.',
+            ].join('\n');
+        }
+        return `Goal set${budgetLabel}: ${truncate(goal.objective, 120)}\nThe agent will keep working until it audits the objective complete${goal.tokenBudget != null ? ' or exhausts the budget' : ''}.`;
+    }
+    catch (e) {
+        return `Failed: ${e?.message || e}`;
+    }
+}
+function formatGoalStatusLine(goal, agent) {
+    if (!goal)
+        return 'No goal set for this session. Use `/goal <objective>` to set one.';
+    if (goal.source === 'claude') {
+        return [
+            `Goal: ${truncate(goal.objective, 200)}`,
+            `Status: ${goal.status}  ·  claude native (Stop hook, auto-clears on completion)`,
+        ].join('\n');
+    }
+    const budget = goal.tokenBudget != null
+        ? `${goal.tokensUsed}/${goal.tokenBudget} tokens`
+        : `${goal.tokensUsed} tokens (no budget)`;
+    const continuations = goal.continuationCount != null ? `  ·  ${goal.continuationCount} continuations` : '';
+    const engine = goal.source === 'codex' ? '  ·  codex native' : '';
+    return [
+        `Goal: ${truncate(goal.objective, 200)}`,
+        `Status: ${goal.status}  ·  ${budget}${continuations}  ·  ${goal.timeUsedSeconds}s elapsed${engine}`,
+    ].join('\n');
+}
+function parseObjective(args) {
+    const m = args.match(/^budget=(\d+)\s+(.+)$/i);
+    if (m) {
+        const tokenBudget = Number.parseInt(m[1], 10);
+        return { objective: m[2].trim(), tokenBudget: Number.isFinite(tokenBudget) && tokenBudget > 0 ? tokenBudget : null };
+    }
+    return { objective: args, tokenBudget: null };
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+export function summarizeSessionRun(session) {
+    if (session.running || session.runState === 'running') {
+        return {
+            state: 'running',
+            shortLabel: 'running',
+            noticeDetail: 'Status: running',
+        };
+    }
+    if (session.runState === 'incomplete') {
+        const detail = String(session.runDetail || '').trim();
+        return {
+            state: 'incomplete',
+            shortLabel: 'unfinished',
+            noticeDetail: detail ? `Status: unfinished · ${detail}` : 'Status: unfinished',
+        };
+    }
+    return {
+        state: 'completed',
+        shortLabel: 'done',
+        noticeDetail: 'Status: completed',
+    };
+}
+export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
+    const cs = bot.chat(chatId);
+    // Workspace-wide: drop the cs.agent filter so the list matches what the
+    // dashboard shows for this workspace (all installed agents, sorted by
+    // most-recent activity).
+    const res = await bot.fetchSessions(undefined, bot.chatWorkdir(chatId));
+    const sessions = res.ok ? res.sessions : [];
+    const total = sessions.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const pg = Math.max(0, Math.min(page, totalPages - 1));
+    const slice = sessions.slice(pg * pageSize, (pg + 1) * pageSize);
+    const agentTotals = {};
+    for (const s of sessions)
+        agentTotals[s.agent] = (agentTotals[s.agent] || 0) + 1;
+    const entries = [];
+    for (const s of slice) {
+        const sessionKey = s.sessionId || '';
+        if (!sessionKey)
+            continue;
+        const status = getSessionStatusForChat(bot, cs, s);
+        const runSummary = summarizeSessionRun({
+            running: status.isRunning,
+            runState: status.isRunning ? 'running' : s.runState,
+            runDetail: s.runDetail,
+        });
+        const displayText = sessionListDisplayTitle(s);
+        const title = displayText ? displayText.replace(/\n/g, ' ').slice(0, 28) : sessionKey.slice(0, 28);
+        const time = s.createdAt
+            ? new Date(s.createdAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
+            : '?';
+        entries.push({
+            key: sessionKey,
+            agent: s.agent,
+            title,
+            time: `${time} · ${runSummary.shortLabel}`,
+            isCurrent: status.isCurrent,
+            isRunning: status.isRunning,
+            runState: runSummary.state,
+            runDetail: s.runDetail,
+        });
+    }
+    return {
+        workspaceName: res.workspaceName || '',
+        agentTotals,
+        total,
+        page: pg,
+        totalPages,
+        sessions: entries,
+    };
+}
+export function extractLastSessionTurn(messages) {
+    if (!messages.length)
+        return null;
+    let lastUserIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'user') {
+            lastUserIndex = i;
+            break;
+        }
+    }
+    const userText = String(lastUserIndex >= 0 ? messages[lastUserIndex].text : '').trim() || null;
+    const assistantTexts = [];
+    for (let i = lastUserIndex >= 0 ? lastUserIndex + 1 : 0; i < messages.length; i++) {
+        if (messages[i].role === 'assistant' && messages[i].text)
+            assistantTexts.push(messages[i].text);
+    }
+    const assistantText = assistantTexts.join('\n\n').trim() || null;
+    if (!userText && !assistantText)
+        return null;
+    return { userText, assistantText };
+}
+export async function getSessionTurnPreviewData(bot, agent, sessionId, limit = 50, workdir) {
+    if (!sessionId)
+        return null;
+    const tail = await bot.fetchSessionTail(agent, sessionId, limit, workdir);
+    if (!tail.ok || !tail.messages.length)
+        return null;
+    return extractLastSessionTurn(tail.messages);
+}
+const AGENT_LABEL_OVERRIDES = {
+    claude: 'Claude Code',
+    codex: 'Codex',
+    gemini: 'Gemini CLI',
+    hermes: 'Hermes',
+};
+function agentDisplayLabel(agentId) {
+    return AGENT_LABEL_OVERRIDES[agentId]
+        || agentId.charAt(0).toUpperCase() + agentId.slice(1);
+}
+/**
+ * Pull the first semver-ish token out of a CLI `--version` string. Falls back
+ * to the original string when no semver is present.
+ *
+ *   "2.1.132 (Claude Code v2.1.132)"  → "2.1.132"
+ *   "Hermes Agent v0.12.0 (2026.4.30)" → "0.12.0"
+ *   "codex-cli 0.128.0"                → "0.128.0"
+ */
+function shortVersion(raw) {
+    if (!raw)
+        return null;
+    const m = raw.match(/\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?/);
+    return m ? m[0] : raw.trim();
+}
+export function getAgentsListData(bot, chatId) {
+    const cs = bot.chat(chatId);
+    const res = bot.fetchAgents();
+    return {
+        currentAgent: cs.agent,
+        agents: res.agents.map(a => {
+            const profile = getActiveProfile(a.agent);
+            const provider = profile ? getProvider(profile.providerId) : null;
+            return {
+                agent: a.agent,
+                label: agentDisplayLabel(a.agent),
+                installed: a.installed,
+                version: a.version ?? null,
+                versionShort: shortVersion(a.version ?? null),
+                path: a.path ?? null,
+                isCurrent: a.agent === cs.agent,
+                boundProvider: provider?.name ?? null,
+                boundModel: profile?.modelId ?? null,
+            };
+        }),
+    };
+}
+export function getSkillsListData(bot, chatId) {
+    const cs = bot.chat(chatId);
+    const skills = bot.fetchSkills(bot.chatWorkdir(chatId)).skills
+        .map(skill => {
+        const command = buildSkillCommandName(skill.name);
+        if (!command)
+            return null;
+        return {
+            name: skill.name,
+            label: skill.label || skill.name.charAt(0).toUpperCase() + skill.name.slice(1),
+            description: skill.description,
+            command,
+            source: skill.source,
+        };
+    })
+        .filter((skill) => !!skill);
+    return { agent: cs.agent, workdir: bot.chatWorkdir(chatId), skills };
+}
+function claudeModelFamily(modelId) {
+    const value = normalizeClaudeModelId(modelId).toLowerCase();
+    if (!value)
+        return null;
+    if (value === 'fable' || value.startsWith('claude-fable-'))
+        return 'fable';
+    if (value === 'opus' || value.startsWith('claude-opus-'))
+        return 'opus';
+    if (value === 'sonnet' || value.startsWith('claude-sonnet-'))
+        return 'sonnet';
+    if (value === 'haiku' || value.startsWith('claude-haiku-'))
+        return 'haiku';
+    return null;
+}
+function isClaudeFamilyAlias(modelId) {
+    const v = modelId.trim().toLowerCase();
+    return v === 'fable' || v === 'opus' || v === 'sonnet' || v === 'haiku';
+}
+export function modelMatchesSelection(agent, selection, currentModel) {
+    if (selection === currentModel)
+        return true;
+    if (agent !== 'claude')
+        return false;
+    if (!isClaudeFamilyAlias(selection) && !isClaudeFamilyAlias(currentModel))
+        return false;
+    const a = claudeModelFamily(selection);
+    const b = claudeModelFamily(currentModel);
+    return !!a && a === b;
+}
+const EFFORT_LEVELS = {
+    claude: [
+        { id: 'low', label: 'Low' },
+        { id: 'medium', label: 'Medium' },
+        { id: 'high', label: 'High' },
+        { id: 'xhigh', label: 'Very High' },
+        { id: 'max', label: 'Max' },
+        // Synthetic top rung: "max depth + multi-agent Workflow orchestration", the
+        // same bundle as Claude's `ultracode` mode. Not a real --effort value — the
+        // bot decomposes it into (effort=max, workflow=on) at apply time.
+        { id: 'ultra', label: 'Ultra' },
+    ],
+    codex: [
+        { id: 'low', label: 'Low' },
+        { id: 'medium', label: 'Medium' },
+        { id: 'high', label: 'High' },
+        { id: 'xhigh', label: 'Very High' },
+    ],
+    hermes: [
+        { id: 'minimal', label: 'Minimal' },
+        { id: 'low', label: 'Low' },
+        { id: 'medium', label: 'Medium' },
+        { id: 'high', label: 'High' },
+        { id: 'xhigh', label: 'Very High' },
+    ],
+};
+function buildEffortData(bot, agent) {
+    // Display value folds workflow into the synthetic `ultra` rung — see
+    // Bot.effortSelectionForAgent.
+    const currentEffort = bot.effortSelectionForAgent(agent);
+    if (!currentEffort)
+        return null;
+    const levels = EFFORT_LEVELS[agent];
+    if (!levels)
+        return null;
+    return {
+        current: currentEffort,
+        levels: levels.map(l => ({ ...l, isCurrent: l.id === currentEffort })),
+    };
+}
+export async function getModelsListData(bot, chatId) {
+    const cs = bot.chat(chatId);
+    const currentModel = bot.modelForAgent(cs.agent);
+    const activeProfileId = bot.activeProfileIdForAgent(cs.agent);
+    const res = await bot.fetchModels(cs.agent, bot.chatWorkdir(chatId));
+    // Match priority:
+    //   - if a Profile is bound, only the row carrying that profileId is current
+    //     (two Profiles can share a modelId, so id-equality alone is ambiguous);
+    //   - otherwise only `'native'` rows are eligible to match against the
+    //     user-config model id.
+    return {
+        agent: cs.agent,
+        currentModel,
+        sources: res.sources,
+        note: res.note ?? null,
+        models: res.models.map(m => {
+            const group = m.group ?? 'native';
+            const isProfileRow = group !== 'native';
+            const isCurrent = activeProfileId
+                ? !!m.profileId && m.profileId === activeProfileId
+                : !isProfileRow && modelMatchesSelection(cs.agent, m.id, currentModel);
+            return {
+                id: m.id,
+                alias: m.alias ?? null,
+                isCurrent,
+                group,
+                profileId: m.profileId ?? null,
+                providerName: m.providerName ?? null,
+            };
+        }),
+        effort: buildEffortData(bot, cs.agent),
+    };
+}
+export async function getStatusDataAsync(bot, chatId) {
+    const d = bot.getStatusData(chatId);
+    const driver = getDriver(d.agent);
+    const usage = driver.getUsageLive
+        ? await driver.getUsageLive({ agent: d.agent, model: d.model }).catch(() => d.usage)
+        : d.usage;
+    return {
+        ...d,
+        running: d.running ? { prompt: d.running.prompt, startedAt: d.running.startedAt } : null,
+        usage,
+        git: readGitStatus(d.workdir),
+    };
+}
+export function getHostDataSync(bot) {
+    return bot.getHostData();
+}
+// ---------------------------------------------------------------------------
+// Skill routing
+// ---------------------------------------------------------------------------
+export { SKILL_CMD_PREFIX, indexSkillsByCommand };
+function relSkillPath(workdir, filePath) {
+    const relative = path.relative(workdir, filePath).replace(/\\/g, '/');
+    return relative && !relative.startsWith('..') ? relative : filePath;
+}
+export function resolveSkillPrompt(bot, chatId, cmd, args) {
+    const wd = bot.chatWorkdir(chatId);
+    const skills = bot.fetchSkills(wd).skills;
+    const skill = indexSkillsByCommand(skills).get(cmd);
+    if (!skill)
+        return null;
+    const extra = args.trim();
+    const suffix = extra ? ` Additional context: ${extra}` : '';
+    const workdirHint = `[Project directory: ${wd}]\n\n`;
+    let prompt;
+    const paths = getProjectSkillPaths(wd, skill.name);
+    const skillFile = paths.claudeSkillFile || paths.sharedSkillFile || paths.agentsSkillFile;
+    if (skillFile) {
+        prompt = `${workdirHint}Read the skill definition at \`${skillFile}\` and execute the instructions defined there.${suffix}`;
+    }
+    else {
+        const fallbackPath = `${wd}/.pikiloop/skills/${skill.name}/SKILL.md`;
+        prompt = `${workdirHint}Read the skill definition at \`${fallbackPath}\` and execute the instructions defined there.${suffix}`;
+    }
+    return { prompt, skillName: skill.name };
+}
+export function getExtensionSummaryData(bot, chatId) {
+    const workdir = bot.chatWorkdir(chatId);
+    const mcpExts = listAllMcpExtensions(workdir);
+    const skillResult = listAllSkills(workdir);
+    return {
+        mcpCount: mcpExts.length,
+        mcpExtensions: mcpExts.map(e => ({
+            name: e.name,
+            scope: e.scope,
+            enabled: e.config.enabled !== false && !e.config.disabled,
+            command: [e.config.command || '', ...(e.config.args || [])].join(' ').trim(),
+        })),
+        skillCount: skillResult.skills.length,
+        skills: skillResult.skills.map((s) => ({
+            name: s.name,
+            scope: s.scope || 'project',
+            label: s.label || s.name,
+        })),
+    };
+}
+// ---------------------------------------------------------------------------
+// Re-export commonly used helpers for convenience
+// ---------------------------------------------------------------------------
+export { summarizePromptForStatus, fmtTokens, fmtUptime, fmtBytes, VERSION };

package/dist/bot/headless-bot.js

@@ -0,0 +1,36 @@
+/**
+ * HeadlessBot — the Web Dashboard acting as a first-class terminal.
+ *
+ * pikiloop's terminals (IM channels and the Dashboard) are equal, pluggable
+ * entry points. The IM channels each have a Bot subclass that connects a chat
+ * transport; the Dashboard needs no transport — it drives the bot directly via
+ * `runtime.getBotRef()`. HeadlessBot fills that gap: it satisfies the Bot
+ * contract (`run()` / `requestStop()`) so `ChannelSupervisor` can manage its
+ * lifecycle exactly like a channel bot and the dashboard can attach to it for
+ * live stream snapshots — but it connects to nothing.
+ *
+ * It exists so the bot is usable with zero IM channels configured: install an
+ * agent, open the dashboard, and you have a working terminal. When an IM
+ * channel is later added, the supervisor tears this down and the channel's bot
+ * takes over the dashboard attachment.
+ */
+import { Bot } from './bot.js';
+export class HeadlessBot extends Bot {
+    resolveRun = null;
+    /**
+     * No transport to connect — just mark the terminal live and block until
+     * `requestStop()` so the supervisor's lifecycle (await runPromise on stop)
+     * matches the channel bots'.
+     */
+    run() {
+        this.connected = true;
+        this.log('dashboard terminal ready (no IM channel configured)');
+        return new Promise(resolve => { this.resolveRun = resolve; });
+    }
+    requestStop() {
+        this.connected = false;
+        super.requestStop();
+        this.resolveRun?.();
+        this.resolveRun = null;
+    }
+}