pikiloop 0.4.0

package/dist/bot/host.js

@@ -0,0 +1,192 @@
+/**
+ * Host system data collection: battery, CPU, memory, display name.
+ * Platform-adaptive with macOS, Linux, and Windows support.
+ */
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+function normalizeBatteryState(raw) {
+    const state = (raw || '').trim().toLowerCase().replace(/\s+/g, ' ');
+    if (!state)
+        return 'unknown';
+    if (state === 'finishing charge')
+        return 'charging';
+    if (state === 'ac attached')
+        return 'plugged in';
+    return state;
+}
+function getMacBatteryData() {
+    try {
+        const output = execSync('pmset -g batt', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output || /no batteries/i.test(output))
+            return null;
+        const line = output.split('\n').find(v => /\d+%/.test(v));
+        if (!line)
+            return null;
+        const percent = line.match(/(\d+)%/)?.[1];
+        if (!percent)
+            return null;
+        const states = line
+            .split(';')
+            .slice(1)
+            .map(segment => segment.replace(/\bpresent:\s*(true|false)\b/ig, '').trim())
+            .filter(Boolean);
+        const state = states.find(segment => /(charging|discharging|charged|not charging|finishing charge|full)/i.test(segment))
+            ?? states.find(segment => !/remaining/i.test(segment))
+            ?? 'unknown';
+        return { percent: `${percent}%`, state: normalizeBatteryState(state) };
+    }
+    catch {
+        return null;
+    }
+}
+function getLinuxBatteryData() {
+    try {
+        const powerDir = '/sys/class/power_supply';
+        const batteries = fs.readdirSync(powerDir).filter(name => /^BAT/i.test(name));
+        for (const battery of batteries) {
+            const batteryDir = path.join(powerDir, battery);
+            const capacityPath = path.join(batteryDir, 'capacity');
+            if (!fs.existsSync(capacityPath))
+                continue;
+            const capacity = fs.readFileSync(capacityPath, 'utf-8').trim();
+            if (!capacity)
+                continue;
+            const statusPath = path.join(batteryDir, 'status');
+            const state = fs.existsSync(statusPath) ? fs.readFileSync(statusPath, 'utf-8').trim() : 'unknown';
+            return {
+                percent: capacity.endsWith('%') ? capacity : `${capacity}%`,
+                state: normalizeBatteryState(state),
+            };
+        }
+    }
+    catch { }
+    try {
+        const output = execSync('upower -e | grep -m1 battery | xargs -I{} upower -i "{}"', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output)
+            return null;
+        const percent = output.match(/percentage:\s*(\d+%)/i)?.[1];
+        if (!percent)
+            return null;
+        const state = output.match(/state:\s*([^\n]+)/i)?.[1];
+        return { percent, state: normalizeBatteryState(state) };
+    }
+    catch {
+        return null;
+    }
+}
+function getWindowsBatteryData() {
+    try {
+        const output = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Battery | Select-Object -First 1 EstimatedChargeRemaining,BatteryStatus | ConvertTo-Json -Compress"', { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (!output || output === 'null')
+            return null;
+        const parsed = JSON.parse(output);
+        const percent = Number(parsed?.EstimatedChargeRemaining);
+        if (!Number.isFinite(percent))
+            return null;
+        const status = Number(parsed?.BatteryStatus);
+        const state = status === 6 ? 'charging'
+            : status === 3 ? 'charged'
+                : status === 2 ? 'plugged in'
+                    : status === 1 ? 'discharging'
+                        : 'unknown';
+        return { percent: `${percent}%`, state };
+    }
+    catch {
+        return null;
+    }
+}
+export function getHostBatteryData() {
+    if (process.platform === 'darwin')
+        return getMacBatteryData();
+    if (process.platform === 'linux')
+        return getLinuxBatteryData();
+    if (process.platform === 'win32')
+        return getWindowsBatteryData();
+    return null;
+}
+function parsePercent(value) {
+    if (!value)
+        return null;
+    const n = Number.parseFloat(value.trim());
+    return Number.isFinite(n) ? n : null;
+}
+function getMacCpuUsageData() {
+    try {
+        const output = execSync('top -l 1 -n 0 | sed -n \'1,6p\'', { encoding: 'utf-8', timeout: 3000 });
+        const line = output.split('\n').find(entry => /^CPU usage:/i.test(entry.trim()));
+        if (!line)
+            return null;
+        const match = line.match(/CPU usage:\s*([\d.]+)% user,\s*([\d.]+)% sys,\s*([\d.]+)% idle/i);
+        if (!match)
+            return null;
+        const userPercent = parsePercent(match[1]);
+        const sysPercent = parsePercent(match[2]);
+        const idlePercent = parsePercent(match[3]);
+        if (userPercent == null || sysPercent == null || idlePercent == null)
+            return null;
+        return {
+            userPercent,
+            sysPercent,
+            idlePercent,
+            usedPercent: Math.max(0, userPercent + sysPercent),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function getMacMemoryUsageData(totalMem) {
+    try {
+        const output = execSync('vm_stat', { encoding: 'utf-8', timeout: 3000 });
+        const pageSize = Number.parseInt(output.match(/page size of (\d+) bytes/i)?.[1] || '', 10);
+        if (!Number.isFinite(pageSize) || pageSize <= 0)
+            return null;
+        const pages = new Map();
+        for (const line of output.split('\n')) {
+            const match = line.match(/^Pages ([^:]+):\s+(\d+)\./);
+            if (!match)
+                continue;
+            pages.set(match[1].trim().toLowerCase(), Number.parseInt(match[2], 10));
+        }
+        const reclaimablePages = (pages.get('free') || 0) +
+            (pages.get('inactive') || 0) +
+            (pages.get('speculative') || 0) +
+            (pages.get('purgeable') || 0);
+        const availableBytes = Math.max(0, reclaimablePages * pageSize);
+        const usedBytes = Math.max(0, Math.min(totalMem, totalMem - availableBytes));
+        const percent = totalMem > 0 ? (usedBytes / totalMem) * 100 : 0;
+        return { usedBytes, availableBytes, percent, source: 'vm_stat' };
+    }
+    catch {
+        return null;
+    }
+}
+export function getHostCpuUsageData() {
+    if (process.platform === 'darwin')
+        return getMacCpuUsageData();
+    return null;
+}
+export function getHostDisplayName() {
+    if (process.platform === 'darwin') {
+        try {
+            const name = execSync('scutil --get ComputerName', { encoding: 'utf-8', timeout: 3000 }).trim();
+            if (name)
+                return name;
+        }
+        catch { /* fall through */ }
+    }
+    return os.hostname();
+}
+export function getHostMemoryUsageData(totalMem, freeMem) {
+    if (process.platform === 'darwin') {
+        const macData = getMacMemoryUsageData(totalMem);
+        if (macData)
+            return macData;
+    }
+    const usedBytes = Math.max(0, totalMem - freeMem);
+    const availableBytes = Math.max(0, freeMem);
+    const percent = totalMem > 0 ? (usedBytes / totalMem) * 100 : 0;
+    return { usedBytes, availableBytes, percent, source: 'os' };
+}

package/dist/bot/human-loop.js

@@ -0,0 +1,168 @@
+/**
+ * Human-in-the-loop prompt state machine and answer helpers.
+ */
+export function createEmptyHumanLoopAnswer() {
+    return {
+        selectedValue: null,
+        freeformText: null,
+        awaitingFreeform: false,
+        skipped: false,
+    };
+}
+export function currentHumanLoopQuestion(prompt) {
+    return prompt.questions[prompt.currentIndex] || null;
+}
+export function isHumanLoopQuestionAnswered(prompt, questionIndex) {
+    const question = prompt.questions[questionIndex];
+    if (!question)
+        return false;
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    if (answer.awaitingFreeform)
+        return false;
+    if (answer.skipped)
+        return true;
+    if (answer.selectedValue)
+        return true;
+    if (answer.freeformText && answer.freeformText.trim())
+        return true;
+    return false;
+}
+export function humanLoopAnsweredCount(prompt) {
+    let count = 0;
+    for (let i = 0; i < prompt.questions.length; i++) {
+        if (isHumanLoopQuestionAnswered(prompt, i))
+            count++;
+    }
+    return count;
+}
+export function isHumanLoopAwaitingText(prompt) {
+    const question = currentHumanLoopQuestion(prompt);
+    if (!question)
+        return false;
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    if (answer.awaitingFreeform)
+        return true;
+    const hasOptions = !!question.options?.length;
+    return !hasOptions;
+}
+export function humanLoopOptionSelected(prompt, optionValue) {
+    const question = currentHumanLoopQuestion(prompt);
+    if (!question)
+        return false;
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    return answer.selectedValue === optionValue && !answer.awaitingFreeform;
+}
+export function setHumanLoopOption(prompt, optionValue, opts = {}) {
+    const question = currentHumanLoopQuestion(prompt);
+    if (!question)
+        return { completed: false, advanced: false };
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    answer.selectedValue = opts.requestFreeform ? null : optionValue;
+    answer.awaitingFreeform = !!opts.requestFreeform;
+    answer.skipped = false;
+    if (!opts.requestFreeform)
+        answer.freeformText = null;
+    prompt.answers[question.id] = answer;
+    if (opts.requestFreeform)
+        return { completed: false, advanced: false };
+    return advanceHumanLoopPrompt(prompt);
+}
+export function setHumanLoopText(prompt, text) {
+    const question = currentHumanLoopQuestion(prompt);
+    if (!question)
+        return { completed: false, advanced: false };
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    answer.freeformText = text;
+    answer.awaitingFreeform = false;
+    answer.skipped = false;
+    prompt.answers[question.id] = answer;
+    return advanceHumanLoopPrompt(prompt);
+}
+export function skipHumanLoopQuestion(prompt) {
+    const question = currentHumanLoopQuestion(prompt);
+    if (!question)
+        return { completed: false, advanced: false };
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    answer.freeformText = null;
+    answer.selectedValue = null;
+    answer.awaitingFreeform = false;
+    answer.skipped = true;
+    prompt.answers[question.id] = answer;
+    return advanceHumanLoopPrompt(prompt);
+}
+function advanceHumanLoopPrompt(prompt) {
+    if (prompt.currentIndex >= prompt.questions.length - 1)
+        return { completed: true, advanced: false };
+    prompt.currentIndex += 1;
+    return { completed: false, advanced: true };
+}
+export function summarizeHumanLoopAnswer(prompt, question) {
+    const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+    const values = [];
+    if (answer.selectedValue)
+        values.push(answer.selectedValue);
+    const freeform = answer.freeformText?.trim();
+    if (freeform)
+        values.push(freeform);
+    const display = answer.skipped
+        ? '(skip)'
+        : values.length
+            ? (question.secret ? '(hidden)' : values.join(' | '))
+            : '(pending)';
+    return {
+        values,
+        display,
+    };
+}
+export function buildHumanLoopResponse(prompt) {
+    const answers = {};
+    for (const question of prompt.questions) {
+        answers[question.id] = summarizeHumanLoopAnswer(prompt, question).values;
+    }
+    return prompt.resolveWith(answers);
+}
+function displayValueForOption(question, value) {
+    const match = question.options?.find(opt => opt.value === value);
+    return match?.label || value;
+}
+/**
+ * Build a channel-agnostic summary of a prompt's resolved answers. Used by the
+ * base bot's `onInteractionAnswered` hook so each channel renders the same
+ * closed-state view + echo message without diverging.
+ */
+export function summarizeResolvedHumanLoopAnswers(prompt, status = 'answered') {
+    const rows = [];
+    const compactParts = [];
+    for (const question of prompt.questions) {
+        const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+        let display;
+        if (answer.skipped) {
+            display = '(skip)';
+        }
+        else if (question.secret && (answer.selectedValue || answer.freeformText)) {
+            display = '(hidden)';
+        }
+        else {
+            const parts = [];
+            if (answer.selectedValue)
+                parts.push(displayValueForOption(question, answer.selectedValue));
+            const freeform = answer.freeformText?.trim();
+            if (freeform)
+                parts.push(freeform);
+            display = parts.length ? parts.join(' · ') : '(no answer)';
+        }
+        const label = (question.header || question.prompt || question.id).trim();
+        rows.push({
+            label,
+            display,
+            skipped: !!answer.skipped,
+            secret: !!question.secret,
+        });
+        compactParts.push(display);
+    }
+    return {
+        status,
+        rows,
+        display: compactParts.join(' · '),
+    };
+}

package/dist/bot/menu.js

@@ -0,0 +1,48 @@
+/**
+ * Menu command definitions and skill-to-command mapping.
+ */
+export const SKILL_CMD_PREFIX = 'sk_';
+export function buildWelcomeIntro(version) {
+    return {
+        title: "Hi, I'm pikiloop",
+        subtitle: 'Send me a message to get started.',
+        version,
+    };
+}
+export function buildSkillCommandName(skillName) {
+    const normalized = skillName.trim().toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    if (!normalized)
+        return null;
+    const cmdName = `${SKILL_CMD_PREFIX}${normalized}`;
+    if (cmdName.length > 32)
+        return null;
+    return cmdName;
+}
+export function indexSkillsByCommand(skills) {
+    const indexed = new Map();
+    for (const skill of skills) {
+        const cmdName = buildSkillCommandName(skill.name);
+        if (!cmdName || indexed.has(cmdName))
+            continue;
+        indexed.set(cmdName, skill);
+    }
+    return indexed;
+}
+export function buildDefaultMenuCommands(agentCount, skills = []) {
+    const commands = [
+        { command: 'sessions', description: 'Switch sessions' },
+    ];
+    if (agentCount > 1) {
+        commands.push({ command: 'agents', description: 'Switch agents' });
+    }
+    commands.push({ command: 'switch', description: 'Change workdir' }, { command: 'workspaces', description: 'Pick saved workspace' }, { command: 'models', description: 'Switch models' }, { command: 'mode', description: 'Toggle plan mode' }, { command: 'goal', description: 'Set/inspect a persistent goal' }, { command: 'stop', description: 'Stop current session' }, { command: 'status', description: 'Show status' }, { command: 'host', description: 'Host info' });
+    if (skills.length) {
+        commands.push({ command: 'skills', description: 'Browse skills' });
+    }
+    commands.push({ command: 'ext', description: 'Extensions overview' });
+    if (agentCount === 1) {
+        commands.push({ command: 'agents', description: 'Switch agents' });
+    }
+    commands.push({ command: 'restart', description: 'Restart bot' });
+    return commands;
+}

package/dist/bot/orchestration.js

@@ -0,0 +1,79 @@
+/**
+ * Session and message orchestration helpers shared across channels.
+ */
+import { buildDefaultMenuCommands } from './menu.js';
+import { BOT_SHUTDOWN_FORCE_EXIT_MS as _BOT_SHUTDOWN_FORCE_EXIT_MS } from '../core/constants.js';
+export const BOT_SHUTDOWN_FORCE_EXIT_MS = _BOT_SHUTDOWN_FORCE_EXIT_MS;
+export function buildBotMenuState(bot) {
+    const agents = bot.fetchAgents().agents;
+    const installedCount = agents.filter(agent => agent.installed).length;
+    const skills = bot.fetchSkills().skills;
+    return {
+        commands: buildDefaultMenuCommands(installedCount, skills),
+        skillCount: skills.length,
+    };
+}
+export function buildSessionTaskId(session, seq, now = Date.now()) {
+    return `${session.key}:${now.toString(36)}:${seq.toString(36)}`;
+}
+export function buildKnownChatEnv(allowedChatIds, knownChatIds, envName) {
+    const ids = new Set();
+    for (const id of allowedChatIds)
+        ids.add(String(id));
+    for (const id of knownChatIds)
+        ids.add(String(id));
+    return ids.size ? { [envName]: [...ids].join(',') } : {};
+}
+export class SessionMessageRegistry {
+    maxPerChat;
+    messages = new Map();
+    constructor(maxPerChat = 1024) {
+        this.maxPerChat = maxPerChat;
+    }
+    clear() {
+        this.messages.clear();
+    }
+    register(chatId, messageId, session, workdir) {
+        if (session.workdir !== workdir)
+            return;
+        if (!this.isValidMessageId(messageId))
+            return;
+        let chatMessages = this.messages.get(chatId);
+        if (!chatMessages) {
+            chatMessages = new Map();
+            this.messages.set(chatId, chatMessages);
+        }
+        chatMessages.set(messageId, {
+            key: session.key,
+            workdir: session.workdir,
+            agent: session.agent,
+            sessionId: session.sessionId,
+            workspacePath: session.workspacePath ?? null,
+            threadId: session.threadId ?? null,
+            codexCumulative: session.codexCumulative,
+            modelId: session.modelId ?? null,
+        });
+        while (chatMessages.size > this.maxPerChat) {
+            const oldest = chatMessages.keys().next();
+            if (oldest.done)
+                break;
+            chatMessages.delete(oldest.value);
+        }
+    }
+    registerMany(chatId, messageIds, session, workdir) {
+        for (const messageId of messageIds)
+            this.register(chatId, messageId, session, workdir);
+    }
+    resolve(chatId, messageId) {
+        if (!this.isValidMessageId(messageId))
+            return null;
+        return this.messages.get(chatId)?.get(messageId) || null;
+    }
+    isValidMessageId(messageId) {
+        if (typeof messageId === 'number')
+            return Number.isFinite(messageId);
+        if (typeof messageId === 'string')
+            return messageId.length > 0;
+        return false;
+    }
+}