@jancellor/ask 1.0.0

package/dist/agent/openai-subscription-fetch.js

@@ -0,0 +1,199 @@
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const ISSUER = "https://auth.openai.com";
+const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+const POLL_SAFETY_MS = 3000;
+function parseJwtClaims(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    }
+    catch {
+        return undefined;
+    }
+}
+function accountIdFromClaims(claims) {
+    return (claims.chatgpt_account_id ||
+        claims["https://api.openai.com/auth"]?.chatgpt_account_id ||
+        claims.organizations?.[0]?.id);
+}
+function extractAccountId(tokens) {
+    if (tokens.id_token) {
+        const claims = parseJwtClaims(tokens.id_token);
+        if (claims) {
+            const id = accountIdFromClaims(claims);
+            if (id)
+                return id;
+        }
+    }
+    const claims = parseJwtClaims(tokens.access_token);
+    if (!claims)
+        return undefined;
+    return accountIdFromClaims(claims);
+}
+function expand(p) {
+    if (!p.startsWith("~/"))
+        return p;
+    return path.join(os.homedir(), p.slice(2));
+}
+function buildStore(tokens) {
+    return {
+        refresh: tokens.refresh_token,
+        access: tokens.access_token,
+        expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+        accountId: extractAccountId(tokens),
+    };
+}
+async function readStore(file) {
+    try {
+        const raw = await readFile(file, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeStore(file, data) {
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(data, null, 2), "utf-8");
+    await chmod(file, 0o600).catch(() => { });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAllowedSubscriptionHost(hostname) {
+    const host = hostname.toLowerCase();
+    return (host === "openai.com" ||
+        host.endsWith(".openai.com") ||
+        host === "chatgpt.com" ||
+        host.endsWith(".chatgpt.com"));
+}
+async function refreshToken(baseFetch, refresh) {
+    const res = await baseFetch(`${ISSUER}/oauth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: refresh,
+            client_id: CLIENT_ID,
+        }).toString(),
+    });
+    if (!res.ok) {
+        throw new Error(`OpenAI OAuth refresh failed: ${res.status}`);
+    }
+    return (await res.json());
+}
+async function loginWithDeviceCode(baseFetch) {
+    const init = await baseFetch(`${ISSUER}/api/accounts/deviceauth/usercode`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ client_id: CLIENT_ID }),
+    });
+    if (!init.ok) {
+        throw new Error(`OpenAI OAuth device start failed: ${init.status}`);
+    }
+    const info = (await init.json());
+    const interval = Math.max(parseInt(info.interval) || 5, 1) * 1000;
+    const prompt = { url: `${ISSUER}/codex/device`, code: info.user_code };
+    console.error(`Open ${prompt.url} and enter code ${prompt.code}`);
+    while (true) {
+        const poll = await baseFetch(`${ISSUER}/api/accounts/deviceauth/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                device_auth_id: info.device_auth_id,
+                user_code: info.user_code,
+            }),
+        });
+        if (poll.ok) {
+            const data = (await poll.json());
+            const token = await baseFetch(`${ISSUER}/oauth/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: new URLSearchParams({
+                    grant_type: "authorization_code",
+                    code: data.authorization_code,
+                    redirect_uri: `${ISSUER}/deviceauth/callback`,
+                    client_id: CLIENT_ID,
+                    code_verifier: data.code_verifier,
+                }).toString(),
+            });
+            if (!token.ok) {
+                throw new Error(`OpenAI OAuth token exchange failed: ${token.status}`);
+            }
+            return (await token.json());
+        }
+        if (poll.status !== 403 && poll.status !== 404) {
+            throw new Error(`OpenAI OAuth device polling failed: ${poll.status}`);
+        }
+        await sleep(interval + POLL_SAFETY_MS);
+    }
+}
+/**
+ * I don't think this works but leaving it plugged in for now.
+ * We might need to set other headers/content in order to use subscriptions.
+ */
+export function createOpenAISubscriptionFetch() {
+    const baseFetch = fetch;
+    const file = expand("~/.config/ask/openai-oauth.json");
+    const skew = 30_000;
+    let inflight;
+    function isMarked(headers) {
+        const value = headers.get("authorization");
+        return value === "Bearer oauth";
+    }
+    function rewriteUrl(url) {
+        if (url.pathname.includes("/v1/responses"))
+            return new URL(CODEX_API_ENDPOINT);
+        if (url.pathname.includes("/chat/completions"))
+            return new URL(CODEX_API_ENDPOINT);
+        return url;
+    }
+    async function ensureAuth() {
+        if (inflight)
+            return inflight;
+        const run = (async () => {
+            const saved = await readStore(file);
+            if (saved && saved.expires > Date.now() + skew) {
+                return saved;
+            }
+            if (saved?.refresh) {
+                const next = buildStore(await refreshToken(baseFetch, saved.refresh));
+                await writeStore(file, next);
+                return next;
+            }
+            const next = buildStore(await loginWithDeviceCode(baseFetch));
+            await writeStore(file, next);
+            return next;
+        })();
+        inflight = run;
+        run.finally(() => {
+            if (inflight === run)
+                inflight = undefined;
+        });
+        return run;
+    }
+    return async (input, init) => {
+        const req = new Request(input, init);
+        if (!isMarked(req.headers)) {
+            return baseFetch(input, init);
+        }
+        const reqUrl = new URL(req.url);
+        if (!isAllowedSubscriptionHost(reqUrl.hostname)) {
+            throw new Error(`OAuth subscription mode requires an OpenAI host, got: ${reqUrl.hostname}`);
+        }
+        const auth = await ensureAuth();
+        const url = rewriteUrl(reqUrl);
+        const out = new Request(url, req);
+        out.headers.set("authorization", `Bearer ${auth.access}`);
+        if (auth.accountId)
+            out.headers.set("ChatGPT-Account-Id", auth.accountId);
+        if (!auth.accountId)
+            out.headers.delete("ChatGPT-Account-Id");
+        return baseFetch(out);
+    };
+}

package/dist/agent/paths.js

@@ -0,0 +1,6 @@
+import { join, parse, sep } from 'path';
+export function ancestorPaths(dir) {
+    const { root } = parse(dir);
+    const parts = dir.slice(root.length).split(sep).filter(Boolean);
+    return Array.from({ length: parts.length + 1 }, (_, i) => join(root, ...parts.slice(0, i)));
+}

package/dist/agent/serializer.js

@@ -0,0 +1,25 @@
+export class Serializer {
+    tail = Promise.resolve();
+    generation = 0;
+    async submit(task) {
+        const generation = this.generation;
+        return this.tail = (async () => {
+            try {
+                await this.tail;
+            }
+            catch (ignored) {
+            }
+            if (this.generation === generation) {
+                await task();
+            }
+        })();
+    }
+    async cancelPending() {
+        this.generation += 1;
+        try {
+            await this.tail;
+        }
+        catch (ignored) {
+        }
+    }
+}

package/dist/agent/session-store.js

@@ -0,0 +1,80 @@
+import { appendFile, copyFile, mkdir, readFile, readdir, stat, } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
+export class SessionStore {
+    sessionId;
+    sessionPath;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+        this.sessionPath = SessionStore.sessionPathFor(sessionId);
+    }
+    static async create(options) {
+        const fallbackLastSessionId = options.resume === true || options.fork !== undefined
+            ? await SessionStore.lastSessionId()
+            : null;
+        const sourceSessionId = SessionStore.parseUuid((typeof options.resume === 'string' ? options.resume : undefined) ??
+            fallbackLastSessionId ??
+            randomUUID());
+        const source = new SessionStore(sourceSessionId);
+        if (!options.fork)
+            return source;
+        return source.forked(options.fork === true ? undefined : options.fork);
+    }
+    static sessionsDir() {
+        return join(homedir(), '.ask', 'sessions');
+    }
+    static sessionPathFor(sessionId) {
+        return join(SessionStore.sessionsDir(), `${sessionId}.jsonl`);
+    }
+    static async lastSessionId() {
+        const dir = SessionStore.sessionsDir();
+        const entries = (await SessionStore.ignoreMissing(() => readdir(dir))) ?? [];
+        const jsonlFiles = entries.filter((f) => f.endsWith('.jsonl'));
+        if (jsonlFiles.length === 0)
+            return null;
+        let latest = null;
+        for (const file of jsonlFiles) {
+            const s = await stat(join(dir, file));
+            if (latest === null || s.mtimeMs > latest.mtimeMs) {
+                latest = { id: file.slice(0, -6), mtimeMs: s.mtimeMs };
+            }
+        }
+        return latest?.id ?? null;
+    }
+    static parseUuid(arg) {
+        const result = z.uuid().safeParse(arg);
+        if (result.success)
+            return result.data;
+        throw new Error(`invalid session UUID: ${arg}`);
+    }
+    static async ignoreMissing(op) {
+        try {
+            return await op();
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    async read() {
+        const content = (await SessionStore.ignoreMissing(() => readFile(this.sessionPath, 'utf-8'))) ?? '';
+        return content
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map((line) => JSON.parse(line));
+    }
+    async append(messages) {
+        await mkdir(SessionStore.sessionsDir(), { recursive: true });
+        const lines = messages.map((message) => JSON.stringify(message) + '\n');
+        await appendFile(this.sessionPath, lines.join(''), 'utf-8');
+    }
+    async forked(sessionId) {
+        const resolvedSessionId = SessionStore.parseUuid(sessionId ?? randomUUID());
+        const forked = new SessionStore(resolvedSessionId);
+        await mkdir(SessionStore.sessionsDir(), { recursive: true });
+        await SessionStore.ignoreMissing(() => copyFile(this.sessionPath, forked.sessionPath));
+        return forked;
+    }
+}

package/dist/agent/session.js

@@ -0,0 +1,87 @@
+import { randomUUID } from 'crypto';
+import { SessionStore, } from './session-store.js';
+export class Session {
+    sessionStore;
+    messagesById;
+    headId = null;
+    constructor(messagesById, headId, sessionStore) {
+        this.messagesById = messagesById;
+        this.headId = headId;
+        this.sessionStore = sessionStore;
+    }
+    static async create(options) {
+        const sessionStore = await SessionStore.create(options);
+        const messagesById = new Map();
+        let headId = null;
+        for (const message of await sessionStore.read()) {
+            const id = message._meta.id;
+            messagesById.set(id, message);
+            headId = id;
+        }
+        return new Session(messagesById, headId, sessionStore);
+    }
+    get sessionId() {
+        return this.sessionStore.sessionId;
+    }
+    get messages() {
+        const messages = [];
+        let currentId = this.headId;
+        const seen = new Set();
+        while (currentId) {
+            if (seen.has(currentId)) {
+                throw new Error(`cycle detected in message graph at: ${currentId}`);
+            }
+            seen.add(currentId);
+            const message = this.messagesById.get(currentId);
+            if (!message)
+                throw new Error(`missing message node: ${currentId}`);
+            messages.push(message);
+            currentId = message._meta.parentId;
+        }
+        return messages.reverse();
+    }
+    async append(messages, uiHidden = false) {
+        if (messages.length === 0)
+            return [];
+        const appended = this.withMeta(messages, uiHidden);
+        await this.sessionStore.append(appended);
+        for (const message of appended) {
+            this.messagesById.set(message._meta.id, message);
+        }
+        const last = appended.at(-1);
+        if (last)
+            this.headId = last._meta.id;
+        return appended;
+    }
+    async cleared() {
+        return new Session(new Map(), null, await SessionStore.create({}));
+    }
+    async fork(sessionId) {
+        this.sessionStore = await this.sessionStore.forked(sessionId);
+    }
+    rewind(headId) {
+        if (headId !== null && !this.messagesById.has(headId)) {
+            throw new Error(`unknown message ID: ${headId}`);
+        }
+        this.headId = headId;
+    }
+    withMeta(messages, uiHidden) {
+        const timestamp = new Date().toISOString();
+        const appended = [];
+        const initialParent = this.headId;
+        for (const [index, message] of messages.entries()) {
+            const id = randomUUID();
+            const parent = index === 0 ? initialParent : appended[index - 1]._meta.id;
+            appended.push({
+                ...message,
+                _meta: {
+                    id,
+                    timestamp,
+                    uiHidden,
+                    parentId: parent ?? null,
+                },
+            });
+        }
+        return appended;
+    }
+}

package/dist/agent/skills-prompt.js

@@ -0,0 +1,56 @@
+import { readdir, readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { basename, join, relative, sep } from 'path';
+import { parse } from 'yaml';
+import { ancestorPaths } from './paths.js';
+export class SkillsPrompt {
+    async build() {
+        const home = homedir();
+        const cwd = process.cwd();
+        const files = (await Promise.all(this.skillsRoots(home, cwd).map((root) => this.skillFiles(root)))).flat();
+        const skills = (await Promise.all(files.map((abs) => this.parseSkill(abs, home, cwd)))).filter((s) => !!s);
+        if (!skills.length)
+            return '';
+        return [
+            'The following agent skills have been loaded from SKILL.md files.\n' +
+                'Agent skills contain additional instructions/code.\n' +
+                'The following are just brief descriptions/summaries indicating relevance.\n' +
+                'Read the full SKILL.md file when relevant to your task.',
+            '<AGENT_SKILLS>',
+            '# Agent skills',
+            ...skills.map((s) => `## \`${s.name}\`\n\nPath: \`${s.path}\`\n\n${s.description}`),
+            '</AGENT_SKILLS>',
+        ].join('\n\n');
+    }
+    skillsRoots(home, cwd) {
+        return [
+            ...new Set([home, ...ancestorPaths(cwd)].map((p) => join(p, '.agents', 'skills'))),
+        ];
+    }
+    async skillFiles(skillsRoot) {
+        try {
+            return (await readdir(skillsRoot, { recursive: true }))
+                .filter((f) => /^skill\.md$/i.test(basename(String(f))))
+                .map((f) => join(skillsRoot, String(f)));
+        }
+        catch {
+            return [];
+        }
+    }
+    async parseSkill(abs, home, cwd) {
+        try {
+            const content = await readFile(abs, 'utf-8');
+            const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            if (!match)
+                return;
+            const fields = parse(match[1]);
+            if (!fields?.name || !fields?.description)
+                return;
+            const path = abs.startsWith(home + sep)
+                ? '~' + abs.slice(home.length)
+                : relative(cwd, abs);
+            return { name: fields.name, path, description: fields.description };
+        }
+        catch { }
+    }
+}

package/dist/agent/system-prompt.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class SystemPrompt {
+    build() {
+        const promptPath = join(__dirname, '..', '..', 'assets', 'system-prompt.md');
+        return readFileSync(promptPath, 'utf-8');
+    }
+}

package/dist/agent/system-prompt.md

@@ -0,0 +1,107 @@
+# System prompt
+
+You are an expert coding agent or coding assistant.
+You are typically invoked via the `ask` executable harness.
+The user may refer to you as "Ask".
+You help users with tasks including coding by executing commands
+including those for searching, reading, editing and writing files.
+
+Available tools:
+
+- `execute`: execute shell commands using bash.
+
+Guidelines:
+
+- Read relevant files and understand context before making changes.
+- Use `execute` for file operations like `ls`, `rg`, `fd`.
+- When summarizing your actions, output plain text directly - do NOT use cat or bash to display what you did.
+- Be concise in your responses.
+- Show file paths clearly when working with files.
+
+## Searching
+
+Use `ls`, `rg`, `fd` for exploring the filesystem.
+Use flags for following symlinks, including hidden items,
+and not ignoring ignored items where appropriate,
+eg `ls -a`, `rg -L -uu`, `fd -L -u`.
+
+## File editing
+
+### Reading
+
+Prefer `sed` to `cat` to avoid dumping large files into context.
+
+```bash
+sed -n '1,200p' path/to/file
+```
+
+### Writing
+
+Use `cat` with heredocs to create new files.
+Check the file doesn't already exist before writing.
+
+```bash
+cat > path/to/new-file <<'EOF'
+<new content>
+EOF
+```
+
+### Editing
+
+Use `sd -F` with `cat` and heredocs for targeted edits.
+Generally prefer making targeted edits rather than rewriting the entire file.
+After editing, read back the modified region to verify.
+
+```bash
+OLD_BLOCK=$(cat <<'OLD_EOF'
+<old content>
+OLD_EOF
+)
+
+NEW_BLOCK=$(cat <<'NEW_EOF'
+<new content>
+NEW_EOF
+)
+
+sd -F -- "$OLD_BLOCK" "$NEW_BLOCK" path/to/file
+```
+
+## Background processes
+
+Use `tmux` when processes need to run in the background.
+For full output, use `capture-pane -S -` or `pipe-pane` to file.
+Prefix session names with "agents-".
+
+## Subagents, task delegation, and context management
+
+Typically the user has invoked you by running `ask` from a terminal shell.
+You may also run `ask "<msg>"` to invoke another copy of the agent,
+which may be referred to as a subagent.
+You may do this in shell commands or in scripts you execute to help you achieve your tasks.
+However you should not use `ask` in code you generate for the user to run independently.
+The point of delegating is to control the context which you, the main agent, and the subagent sees.
+If you need to answer a complicated query in the middle of a conversation, by delegating to a subagent,
+the subagent does not see the unnecessary full context of your conversation.
+It only sees what you explicitly include in the prompt.
+Similarly, you do not see the output of the intermediate steps the subagent used to answer the question.
+By keeping the context of yourself and subagents limited to only the scope they require,
+overall accuracy is typically improved.
+Also, by invoking multiple subagents in a single turn, you can achieve parallelism
+and therefore faster performance for tasks that are truly independent.
+
+## Session storage
+
+When `ask` runs, messages are persisted to `~/.ask/sessions/<id>.jsonl` as AI SDK messages.
+IDs are UUIDs.
+Messages include additional metadata in a `_meta` property, including `id`, `parentId`, `uiHidden`, and `timestamp`.
+When using subagents, consider passing an explicit session ID via `ask --resume <id> ...`.
+This allows you to inspect the context of the subagent, though note that
+usually you explicitly don't want the subagent context in your own.
+This also allows you ask a subagent follow up question by supplying the same session ID twice.
+It may be useful to make focused searches of the subagent context.
+
+## Web
+
+For searching or fetching from the web, you may delegate to `codex`, another coding agent.
+
+    codex exec --skip-git-repo-check "What is the weather like in London today?"

package/dist/agent/tools.js

@@ -0,0 +1,17 @@
+import { ExecuteTool } from './execute-tool.js';
+export class Tools {
+    executeTool = new ExecuteTool();
+    definitions() {
+        return {
+            [this.executeTool.name]: this.executeTool.definition(),
+        };
+    }
+    execute(name, args, signal) {
+        switch (name) {
+            case this.executeTool.name:
+                return this.executeTool.execute(args, signal);
+            default:
+                throw new Error(`unknown tool: ${name}`);
+        }
+    }
+}