pikiloop 0.4.0

package/dist/dashboard/session-control.js

@@ -0,0 +1,347 @@
+/**
+ * Public session task control surface for dashboard and API routes.
+ */
+import path from 'node:path';
+import { getProjectSkillPaths, listSkills, stageSessionFiles, ensureManagedSession, findPikiloopSession, getDriverCapabilities, isPendingSessionId } from '../agent/index.js';
+import { loadUserConfig } from '../core/config/user-config.js';
+import { decomposeEffortSelection } from '../core/config/runtime-config.js';
+import { runtime } from './runtime.js';
+const KNOWN_AGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
+/**
+ * Parse a `/goal[ args]` prompt typed in the dashboard chat box. Returns null
+ * when the prompt is not a goal slash command. Sub-commands mirror the IM
+ * `handleGoalCommand` semantics (set / clear / pause / resume / status).
+ *
+ * Routing /goal through the native bridge is the dashboard's analog of what
+ * channels/{telegram,feishu,weixin}/bot.ts do via `handleGoalCommand` — before
+ * this hook, dashboard /goal was matched by the legacy `goal` skill resolver
+ * and silently rewritten to "Read SKILL.md and execute", which bypassed both
+ * the claude native /goal slash command and codex's thread/goal RPC.
+ */
+function parseGoalSlash(prompt) {
+    const trimmed = prompt.trim();
+    const m = trimmed.match(/^\/goal(?:\s+([\s\S]*))?$/);
+    if (!m)
+        return null;
+    const args = (m[1] || '').trim();
+    if (!args)
+        return { action: 'status', objective: '' };
+    const lower = args.toLowerCase();
+    if (lower === 'clear' || lower === 'cancel' || lower === 'stop')
+        return { action: 'clear', objective: '' };
+    if (lower === 'pause')
+        return { action: 'pause', objective: '' };
+    if (lower === 'resume')
+        return { action: 'resume', objective: '' };
+    return { action: 'set', objective: args };
+}
+/**
+ * Resolve a `/skill-name [args]` prompt into the full skill execution prompt.
+ * Returns null if the prompt is not a skill invocation or the skill is not found.
+ */
+function resolveSkillFromPrompt(workdir, prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    // Extract command name and args: "/skill-name some args" → name="skill-name", args="some args"
+    const match = trimmed.match(/^\/([^\s]+)(?:\s+(.*))?$/s);
+    if (!match)
+        return null;
+    const name = match[1];
+    const args = (match[2] || '').trim();
+    const { skills } = listSkills(workdir);
+    // Match by exact skill name (case-insensitive)
+    const skill = skills.find(s => s.name.toLowerCase() === name.toLowerCase());
+    if (!skill)
+        return null;
+    const extra = args ? ` Additional context: ${args}` : '';
+    const workdirHint = `[Project directory: ${workdir}]\n\n`;
+    const paths = getProjectSkillPaths(workdir, skill.name);
+    const skillFile = paths.claudeSkillFile || paths.sharedSkillFile || paths.agentsSkillFile;
+    const targetPath = skillFile || `${workdir}/.pikiloop/skills/${skill.name}/SKILL.md`;
+    const resolvedPrompt = `${workdirHint}Read the skill definition at \`${targetPath}\` and execute the instructions defined there.${extra}`;
+    return { resolvedPrompt, skillName: skill.name };
+}
+/**
+ * Resolve a `handoverFrom` ref from the request's `previousAgent` /
+ * `previousSessionId` fields, validating that it points to a real, non-self,
+ * different-agent session managed by pikiloop. Returns null when the inputs
+ * are absent or invalid — handover is best-effort and silent-skip on bad data.
+ */
+function resolveHandoverFrom(request, targetAgent) {
+    const prevAgent = typeof request.previousAgent === 'string' ? request.previousAgent.trim() : '';
+    const prevSessionId = typeof request.previousSessionId === 'string' ? request.previousSessionId.trim() : '';
+    if (!prevAgent || !prevSessionId)
+        return null;
+    if (!KNOWN_AGENTS.has(prevAgent))
+        return null;
+    if (prevAgent === targetAgent)
+        return null; // same-agent continuation goes via --resume, not handover
+    if (isPendingSessionId(prevSessionId))
+        return null; // no native history yet → nothing to compact
+    const record = findPikiloopSession(request.workdir, prevAgent, prevSessionId);
+    if (!record)
+        return null;
+    return { agent: prevAgent, sessionId: prevSessionId };
+}
+export async function queueDashboardSessionTask(request) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    if (!request.workdir || (!request.prompt && !(request.attachments || []).length)) {
+        return { ok: false, error: 'workdir and either prompt or attachments are required' };
+    }
+    const config = loadUserConfig();
+    const resolvedAgent = typeof request.agent === 'string' && KNOWN_AGENTS.has(request.agent)
+        ? request.agent
+        : runtime.getRuntimeDefaultAgent(config);
+    const modelId = typeof request.model === 'string' ? request.model.trim() : '';
+    // "ultra" is a synthetic effort rung = max depth + Workflow orchestration;
+    // decompose it so the spawn carries a real --effort value plus the workflow
+    // flag (the per-send pick is the single knob — no separate workflow control).
+    const { effort: splitEffort, workflow: ultraWorkflow } = decomposeEffortSelection(typeof request.effort === 'string' ? request.effort : '');
+    const thinkingEffort = resolvedAgent === 'gemini' ? '' : splitEffort;
+    const workflowEnabled = ultraWorkflow || request.workflow === true;
+    // /goal — route directly to the goal bridge (claude native slash, codex RPC,
+    // or portable goal.json for gemini/hermes). Must run BEFORE skill resolution
+    // so the legacy `goal` skill doesn't grab the prompt and rewrite it into a
+    // "Read SKILL.md" instruction.
+    const goalCmd = parseGoalSlash(request.prompt || '');
+    if (goalCmd && request.sessionId && !isPendingSessionId(request.sessionId)) {
+        return runDashboardGoalSlash(bot, resolvedAgent, request, goalCmd, modelId, thinkingEffort);
+    }
+    // Resolve /skill-name prompts into full skill execution prompts
+    let prompt = request.prompt;
+    const skillResult = prompt ? resolveSkillFromPrompt(request.workdir, prompt) : null;
+    if (skillResult) {
+        prompt = skillResult.resolvedPrompt;
+        runtime.debug(`[session-send] resolved skill: ${skillResult.skillName}`);
+    }
+    let sessionId = request.sessionId;
+    let attachments = request.attachments || [];
+    // Resolve handover source. Only meaningful when we're about to stage a fresh
+    // session (sessionId blank or pending). For an existing session we never
+    // replay handover — that session's own --resume history is canonical.
+    const isFreshSession = !sessionId || isPendingSessionId(sessionId);
+    const handoverFrom = isFreshSession ? resolveHandoverFrom(request, resolvedAgent) : null;
+    // Stage files into the session workspace so temp uploads survive cleanup.
+    // Also creates a new pending session when no sessionId is provided.
+    if (!sessionId || attachments.length) {
+        const staged = stageSessionFiles({
+            agent: resolvedAgent,
+            workdir: request.workdir,
+            files: attachments,
+            sessionId: sessionId || null,
+            title: request.prompt || 'New session',
+            threadId: null,
+            handoverFrom,
+        });
+        if (!sessionId)
+            sessionId = staged.sessionId;
+        if (staged.importedFiles.length) {
+            attachments = staged.importedFiles.map(f => path.join(staged.workspacePath, f));
+        }
+    }
+    return bot.submitSessionTask({
+        workdir: request.workdir,
+        agent: resolvedAgent,
+        sessionId,
+        prompt: prompt || 'Please inspect the attached file(s).',
+        attachments,
+        ...(modelId ? { modelId } : {}),
+        ...(thinkingEffort ? { thinkingEffort } : {}),
+        // Always thread the per-send workflow choice (even when false) so the run
+        // explicitly reflects the picked rung (Ultra ⇒ on) rather than any ambient
+        // default.
+        workflowEnabled,
+        ...(handoverFrom ? { handoverFrom } : {}),
+    });
+}
+async function runDashboardGoalSlash(bot, agent, request, cmd, modelId, thinkingEffort) {
+    const opts = { chatId: 'dashboard', modelId: modelId || undefined, thinkingEffort: thinkingEffort || undefined };
+    const sessionKey = `${agent}:${request.sessionId}`;
+    // Synthetic task id — for set / clear / resume on agents that internally
+    // submit a follow-up task (claude native slash, portable continuation),
+    // the real task id is owned by submitSessionTask. The dashboard's SSE
+    // stream listener picks that up via session events; this id is just to
+    // give the HTTP caller a non-empty taskId field.
+    const taskId = `goal-${cmd.action}-${Date.now().toString(36)}`;
+    try {
+        if (cmd.action === 'status') {
+            const goal = await bot.getSessionGoal(request.workdir, agent, request.sessionId);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        if (cmd.action === 'clear') {
+            await bot.clearSessionGoal(request.workdir, agent, request.sessionId, opts);
+            return { ok: true, taskId, sessionKey, queued: false };
+        }
+        if (cmd.action === 'pause') {
+            const goal = await bot.pauseSessionGoal(request.workdir, agent, request.sessionId);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        if (cmd.action === 'resume') {
+            const goal = await bot.resumeSessionGoal(request.workdir, agent, request.sessionId, opts);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        // set
+        const goal = await bot.setSessionGoal(request.workdir, agent, request.sessionId, {
+            objective: cmd.objective,
+            ...opts,
+        });
+        return { ok: true, taskId, sessionKey, queued: true, goal };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message || String(e) };
+    }
+}
+export function forkDashboardSessionTask(request) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    if (!request.workdir || !request.parentSessionId || !request.prompt) {
+        return { ok: false, error: 'workdir, parentSessionId, and prompt are required' };
+    }
+    if (!KNOWN_AGENTS.has(request.agent)) {
+        return { ok: false, error: `Unknown agent: ${request.agent}` };
+    }
+    const agent = request.agent;
+    if (!getDriverCapabilities(agent).fork) {
+        return { ok: false, error: `Agent ${agent} does not support fork` };
+    }
+    const modelId = typeof request.model === 'string' ? request.model.trim() : '';
+    // Same "ultra" decomposition as the send path — a forked turn launched at
+    // Ultra inherits max depth + Workflow orchestration.
+    const { effort: splitEffort, workflow: ultraWorkflow } = decomposeEffortSelection(typeof request.effort === 'string' ? request.effort : '');
+    const thinkingEffort = agent === 'gemini' ? '' : splitEffort;
+    // Resolve /skill-name shorthand the same way send/queue does, so a forked
+    // turn that starts with `/skill-name` runs the skill against the child.
+    let prompt = request.prompt;
+    const skillResult = prompt ? resolveSkillFromPrompt(request.workdir, prompt) : null;
+    if (skillResult)
+        prompt = skillResult.resolvedPrompt;
+    // Make sure the parent has a managed record so `recordFork` (called after the
+    // child stream completes) can write the lineage on both sides. Native-only
+    // sessions (started outside pikiloop) won't have a record yet.
+    ensureManagedSession({
+        agent,
+        workdir: request.workdir,
+        sessionId: request.parentSessionId,
+    });
+    // Always create a fresh pending session for the child. stageSessionFiles
+    // also handles attachment imports into the new workspace.
+    const staged = stageSessionFiles({
+        agent,
+        workdir: request.workdir,
+        files: request.attachments || [],
+        sessionId: null,
+        title: request.prompt || `Fork from ${request.parentSessionId.slice(0, 8)}`,
+        threadId: null,
+    });
+    const attachments = staged.importedFiles.length
+        ? staged.importedFiles.map(f => path.join(staged.workspacePath, f))
+        : [];
+    return bot.submitSessionTask({
+        workdir: request.workdir,
+        agent,
+        sessionId: staged.sessionId,
+        prompt: prompt || 'Please inspect the attached file(s).',
+        attachments,
+        forkOf: { parentSessionId: request.parentSessionId, atTurn: request.atTurn },
+        ...(modelId ? { modelId } : {}),
+        ...(thinkingEffort ? { thinkingEffort } : {}),
+        ...(ultraWorkflow ? { workflowEnabled: true } : {}),
+    });
+}
+export function getSessionStreamState(agent, sessionId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: true, state: null };
+    return { ok: true, state: bot.getStreamSnapshot(`${agent}:${sessionId}`) };
+}
+export function cancelSessionTask(taskId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.cancelTask(taskId);
+    return { ok: true, recalled: result.cancelled || result.interrupted };
+}
+/**
+ * Stop only the currently running task for a session — queued follow-ups are
+ * preserved and run normally once the chain advances. Works on (agent,
+ * sessionId) rather than a single taskId so it still functions during the
+ * brief window after send/before the queued WS snapshot reaches the client.
+ * Per-row × buttons (→ cancelSessionTask) cancel one queued entry at a time.
+ */
+export function stopSessionTasks(agent, sessionId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.stopAllSessionTasks(`${agent}:${sessionId}`);
+    return { ok: true, ...result };
+}
+export async function steerSessionTask(taskId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = await bot.steerTask(taskId);
+    return { ok: true, steered: result.steered };
+}
+// ---------------------------------------------------------------------------
+// Interaction prompt control (human-in-the-loop)
+// ---------------------------------------------------------------------------
+export function interactionSelectOption(promptId, optionValue, opts) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSelectOption(promptId, optionValue, opts);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionSubmitText(promptId, text) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSubmitText(promptId, text);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or not awaiting text' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionSkip(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSkip(promptId);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionCancel(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionCancel(promptId);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true };
+}
+export function getInteractionPrompt(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const prompt = bot.interactionPrompt(promptId);
+    if (!prompt)
+        return { ok: true, prompt: null };
+    return {
+        ok: true,
+        prompt: {
+            promptId: prompt.promptId,
+            taskId: prompt.taskId,
+            title: prompt.title,
+            hint: prompt.hint,
+            questions: prompt.questions,
+            currentIndex: prompt.currentIndex,
+            answers: prompt.answers,
+        },
+    };
+}

package/dist/model/catalog.js

@@ -0,0 +1,104 @@
+/**
+ * models.dev catalog — read-only metadata about LLM providers and their
+ * models (pricing, context window, capabilities). We hit the public JSON
+ * endpoint and cache the result locally for 24h, with a fallback to the
+ * cached copy when offline.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { request } from 'undici';
+import { STATE_DIR_NAME } from '../core/constants.js';
+const MODELS_DEV_URL = 'https://models.dev/api.json';
+const CACHE_PATH = path.join(os.homedir(), STATE_DIR_NAME, 'models-dev-cache.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 8_000;
+let memCache = null;
+let inflight = null;
+function readDiskCache() {
+    try {
+        const raw = fs.readFileSync(CACHE_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.fetchedAt && parsed.data) {
+            return parsed;
+        }
+    }
+    catch { }
+    return null;
+}
+function writeDiskCache(env) {
+    try {
+        fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+        fs.writeFileSync(CACHE_PATH, JSON.stringify(env), { mode: 0o644 });
+    }
+    catch { }
+}
+async function fetchFromNetwork() {
+    const { body, statusCode } = await request(MODELS_DEV_URL, {
+        method: 'GET',
+        headersTimeout: FETCH_TIMEOUT_MS,
+        bodyTimeout: FETCH_TIMEOUT_MS,
+    });
+    if (statusCode < 200 || statusCode >= 300) {
+        throw new Error(`models.dev returned HTTP ${statusCode}`);
+    }
+    const text = await body.text();
+    return JSON.parse(text);
+}
+/**
+ * Get the catalog. Returns a cached copy if fresh; otherwise fetches in the
+ * background and falls back to the stale cache on failure.
+ */
+export async function getModelsDevCatalog(opts = {}) {
+    const now = Date.now();
+    if (!opts.forceRefresh && memCache && now - memCache.fetchedAt < CACHE_TTL_MS) {
+        return memCache.data;
+    }
+    if (!memCache)
+        memCache = readDiskCache();
+    if (!opts.forceRefresh && memCache && now - memCache.fetchedAt < CACHE_TTL_MS) {
+        return memCache.data;
+    }
+    if (!inflight) {
+        inflight = (async () => {
+            try {
+                const data = await fetchFromNetwork();
+                const env = { fetchedAt: Date.now(), data };
+                memCache = env;
+                writeDiskCache(env);
+                return data;
+            }
+            catch (e) {
+                if (memCache)
+                    return memCache.data; // fall back to stale cache
+                throw e;
+            }
+            finally {
+                inflight = null;
+            }
+        })();
+    }
+    return inflight;
+}
+/** Lookup a single provider by its models.dev id (e.g. "openrouter"). */
+export async function getCatalogProvider(providerId) {
+    const cat = await getModelsDevCatalog().catch(() => null);
+    return cat?.[providerId] || null;
+}
+/** Lookup a model entry within a provider. */
+export async function getCatalogModel(providerId, modelId) {
+    const provider = await getCatalogProvider(providerId);
+    return provider?.models?.[modelId] || null;
+}
+/**
+ * Lightweight search: returns providers whose id/name match the query.
+ * If query is empty, returns all providers sorted by id.
+ */
+export async function searchCatalogProviders(query) {
+    const cat = await getModelsDevCatalog().catch(() => ({}));
+    const all = Object.values(cat);
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return all.sort((a, b) => a.id.localeCompare(b.id));
+    return all.filter(p => p.id.toLowerCase().includes(q) || p.name.toLowerCase().includes(q));
+}

package/dist/model/index.js

@@ -0,0 +1,20 @@
+/**
+ * Pikiloop "Model" layer — barrel export.
+ *
+ * The Model layer is one of the four physical layers in pikiloop's
+ * architecture (Terminal / Agent / **Model** / Tool). It centralises:
+ *   - Provider/Profile data model (types.ts)
+ *   - Read-only catalog of providers/models from models.dev (catalog.ts)
+ *   - Persistence (store.ts) over ~/.pikiloop/setting.json
+ *   - Feishu-style credential validation (validation.ts)
+ *   - Per-agent credential injection at spawn time (injector.ts)
+ *
+ * Adding a new agent driver only needs to:
+ *   1. Define a new AgentInjector entry in injector.ts
+ *   2. Read `resolveAgentInjection(agentId)` before spawning
+ */
+export { getModelsDevCatalog, getCatalogProvider, getCatalogModel, searchCatalogProviders, } from './catalog.js';
+export { listProviders, getProvider, addProvider, updateProvider, removeProvider, setProviderValidation, listProfiles, getProfile, addProfile, updateProfile, removeProfile, getActiveProfileId, getActiveProfile, setActiveProfile, } from './store.js';
+export { validateProvider } from './validation.js';
+export { resolveAgentInjection, isAgentBoundToProfile, } from './injector.js';
+export { getProviderModelList, invalidateProviderModels, peekProviderModelList, peekProviderModelInfo, prefetchProviderModels, } from './provider-models.js';