oioxo-mcp 0.1.0

package/dist/core/code-graph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * OIOXO code graph — ported from the web IDE's Context Compiler. Deterministic,
+ * on-device, no model. Builds import/dependency edges between project files so
+ * retrieval can EXPAND from task-relevant "anchor" files to the files they
+ * actually depend on — graph expansion beats flat term-overlap retrieval.
+ * Resolves relative imports against the project's own files (node_modules are
+ * not editable and would be noise).
+ */
+import type { ProjectFile } from './files.js';
+/** Pull import/require/dynamic-import specifiers from a source file. */
+export declare function importSpecifiers(content: string): string[];
+/** Resolve a relative import to a project file path (extension + /index tries). */
+export declare function resolveImport(spec: string, fromFile: string, fileSet: Set<string>): string | null;
+export interface CodeGraph {
+    /** file → the in-project files it imports (direct dependencies). */
+    deps: Map<string, string[]>;
+    /** file → the in-project files that import it (dependents / reverse edges). */
+    dependents: Map<string, string[]>;
+}
+export declare function buildGraph(files: ProjectFile[]): CodeGraph;
+/**
+ * Expand anchors along graph edges up to `hops` deep — anchors PLUS their
+ * (transitive) dependencies, optionally one hop of dependents. Capped.
+ */
+export declare function expandContext(graph: CodeGraph, anchors: string[], opts?: {
+    hops?: number;
+    includeDependents?: boolean;
+    max?: number;
+}): string[];

package/dist/core/code-graph.js

@@ -0,0 +1,105 @@
+const CODE_RE = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+/** Pull import/require/dynamic-import specifiers from a source file. */
+export function importSpecifiers(content) {
+    const specs = [];
+    const patterns = [
+        /import\s+[^'"]*?from\s*['"]([^'"]+)['"]/g,
+        /import\s*['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+[^'"]*?from\s*['"]([^'"]+)['"]/g,
+    ];
+    for (const re of patterns) {
+        let m;
+        while ((m = re.exec(content)))
+            specs.push(m[1]);
+    }
+    return specs;
+}
+function normalize(p) {
+    const parts = p.split('/');
+    const out = [];
+    for (const part of parts) {
+        if (part === '' || part === '.')
+            continue;
+        if (part === '..')
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out.join('/');
+}
+const dirOf = (p) => p.split('/').slice(0, -1).join('/');
+/** Resolve a relative import to a project file path (extension + /index tries). */
+export function resolveImport(spec, fromFile, fileSet) {
+    if (!spec.startsWith('.'))
+        return null;
+    const base = normalize(dirOf(fromFile) + '/' + spec);
+    const exts = ['', '.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'];
+    for (const e of exts)
+        if (fileSet.has(base + e))
+            return base + e;
+    for (const e of exts.slice(1))
+        if (fileSet.has(base + '/index' + e))
+            return base + '/index' + e;
+    return null;
+}
+export function buildGraph(files) {
+    const code = files.filter((f) => CODE_RE.test(f.path));
+    const fileSet = new Set(code.map((f) => f.path));
+    const deps = new Map();
+    const dependents = new Map();
+    for (const f of code) {
+        const resolved = [];
+        for (const spec of importSpecifiers(f.content)) {
+            const r = resolveImport(spec, f.path, fileSet);
+            if (r && r !== f.path && !resolved.includes(r))
+                resolved.push(r);
+        }
+        deps.set(f.path, resolved);
+        for (const r of resolved) {
+            const arr = dependents.get(r) ?? [];
+            if (!arr.includes(f.path))
+                arr.push(f.path);
+            dependents.set(r, arr);
+        }
+    }
+    return { deps, dependents };
+}
+/**
+ * Expand anchors along graph edges up to `hops` deep — anchors PLUS their
+ * (transitive) dependencies, optionally one hop of dependents. Capped.
+ */
+export function expandContext(graph, anchors, opts = {}) {
+    const hops = opts.hops ?? 2;
+    const max = opts.max ?? 12;
+    const seen = new Set(anchors);
+    let frontier = [...anchors];
+    for (let h = 0; h < hops && seen.size < max; h++) {
+        const next = [];
+        for (const f of frontier) {
+            for (const d of graph.deps.get(f) ?? []) {
+                if (!seen.has(d)) {
+                    seen.add(d);
+                    next.push(d);
+                    if (seen.size >= max)
+                        break;
+                }
+            }
+            if (opts.includeDependents && h === 0) {
+                for (const d of graph.dependents.get(f) ?? []) {
+                    if (!seen.has(d)) {
+                        seen.add(d);
+                        next.push(d);
+                        if (seen.size >= max)
+                            break;
+                    }
+                }
+            }
+            if (seen.size >= max)
+                break;
+        }
+        frontier = next;
+    }
+    return [...anchors, ...Array.from(seen).filter((f) => !anchors.includes(f))].slice(0, max);
+}

package/dist/core/files.d.ts

@@ -0,0 +1,17 @@
+export interface ProjectFile {
+    /** Workspace-relative path with forward slashes (the engine's canonical form). */
+    path: string;
+    content: string;
+}
+export declare const MAX_FILES = 1500;
+export declare const MAX_FILE_BYTES: number;
+/** Enumerate indexable files under `root` (breadth-first, bounded). */
+export declare function listProjectFiles(root: string, opts?: {
+    maxFiles?: number;
+}): Promise<string[]>;
+/** Read one project file (size/binary guarded). Returns null when skipped. */
+export declare function readProjectFile(root: string, rel: string): Promise<ProjectFile | null>;
+/** Load the whole indexable project (bounded). */
+export declare function loadProject(root: string, opts?: {
+    maxFiles?: number;
+}): Promise<ProjectFile[]>;

package/dist/core/files.js

@@ -0,0 +1,88 @@
+/**
+ * Workspace file enumeration for the OIOXO context engine. Walks the project
+ * tree with the same include/exclude policy as the OIOXO IDEs (source-ish files
+ * only, skip build output / deps / media), bounded so a huge monorepo can't
+ * exhaust memory. 100% local — file contents never leave the machine.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+export const MAX_FILES = 1500;
+export const MAX_FILE_BYTES = 256 * 1024;
+const INCLUDE_EXT = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts',
+    '.py', '.go', '.rs', '.java', '.rb', '.php', '.c', '.h', '.cpp', '.cs',
+    '.swift', '.kt', '.vue', '.svelte', '.css', '.scss', '.html', '.json',
+    '.md', '.yml', '.yaml', '.sql', '.sh',
+]);
+const EXCLUDE_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'out', '.next', 'coverage',
+    'vendor', '.oioxo', '.vscode', '.cursor', '.idea', '__pycache__', '.venv', 'venv',
+]);
+/** A NUL byte in the first 1KB reliably marks a binary file. */
+function isBinary(text) {
+    const n = Math.min(text.length, 1024);
+    for (let i = 0; i < n; i++)
+        if (text.charCodeAt(i) === 0)
+            return true;
+    return false;
+}
+const looksMinified = (name) => /\.min\.[a-z]+$/.test(name);
+/** Enumerate indexable files under `root` (breadth-first, bounded). */
+export async function listProjectFiles(root, opts = {}) {
+    const maxFiles = opts.maxFiles ?? MAX_FILES;
+    const found = [];
+    const queue = [''];
+    while (queue.length && found.length < maxFiles) {
+        const rel = queue.shift();
+        let entries;
+        try {
+            entries = await fs.readdir(path.join(root, rel), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        // Stable order so retrieval is deterministic across runs.
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+            if (found.length >= maxFiles)
+                break;
+            const childRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (!EXCLUDE_DIRS.has(e.name) && !e.name.startsWith('.'))
+                    queue.push(childRel);
+            }
+            else if (e.isFile()) {
+                if (INCLUDE_EXT.has(path.extname(e.name).toLowerCase()) && !looksMinified(e.name))
+                    found.push(childRel);
+            }
+        }
+    }
+    return found;
+}
+/** Read one project file (size/binary guarded). Returns null when skipped. */
+export async function readProjectFile(root, rel) {
+    const abs = path.join(root, rel);
+    try {
+        const stat = await fs.stat(abs);
+        if (stat.size > MAX_FILE_BYTES)
+            return null;
+        const content = await fs.readFile(abs, 'utf8');
+        if (!content || isBinary(content))
+            return null;
+        return { path: rel.replace(/\\/g, '/'), content };
+    }
+    catch {
+        return null;
+    }
+}
+/** Load the whole indexable project (bounded). */
+export async function loadProject(root, opts = {}) {
+    const rels = await listProjectFiles(root, opts);
+    const out = [];
+    for (const rel of rels) {
+        const f = await readProjectFile(root, rel);
+        if (f)
+            out.push(f);
+    }
+    return out;
+}

package/dist/core/memory.d.ts

@@ -0,0 +1,12 @@
+export declare const OIOXO_DIR = ".oioxo";
+export declare const RULES_FILE = "rules.md";
+export declare const MEMORY_FILE = "memory.md";
+export interface ProjectContext {
+    rules: string;
+    memory: string;
+}
+export declare function readProjectContext(root: string): Promise<ProjectContext>;
+/** Append one learned fact as a bullet — deduped, bounded FIFO. */
+export declare function rememberFact(root: string, fact: string): Promise<void>;
+/** Format rules+memory as an injectable block (mirrors the IDE injection). */
+export declare function contextBlock(ctx: ProjectContext): string;

package/dist/core/memory.js

@@ -0,0 +1,55 @@
+/**
+ * OIOXO project memory — the same `.oioxo/` contract the OIOXO IDEs use
+ * (rules.md = durable conventions the user writes; memory.md = bounded facts
+ * the agent learns). One format across desktop, web and MCP, so a project
+ * carries its knowledge between every surface. 100% on-device.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+export const OIOXO_DIR = '.oioxo';
+export const RULES_FILE = 'rules.md';
+export const MEMORY_FILE = 'memory.md';
+// Bounds match the desktop service so no surface ever bloats the file.
+const MAX_MEMORY_BULLETS = 40;
+const MAX_MEMORY_CHARS = 4000;
+async function readIfExists(p) {
+    try {
+        return (await fs.readFile(p, 'utf8')).trim();
+    }
+    catch {
+        return '';
+    }
+}
+export async function readProjectContext(root) {
+    const dir = path.join(root, OIOXO_DIR);
+    return {
+        rules: await readIfExists(path.join(dir, RULES_FILE)),
+        memory: await readIfExists(path.join(dir, MEMORY_FILE)),
+    };
+}
+/** Append one learned fact as a bullet — deduped, bounded FIFO. */
+export async function rememberFact(root, fact) {
+    const clean = fact.replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return;
+    const dir = path.join(root, OIOXO_DIR);
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, MEMORY_FILE);
+    const existing = await readIfExists(file);
+    let bullets = existing.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('- '));
+    const lower = clean.toLowerCase();
+    bullets = bullets.filter((b) => b.slice(2).toLowerCase() !== lower);
+    bullets.push(`- ${clean}`);
+    while (bullets.length > MAX_MEMORY_BULLETS || bullets.join('\n').length > MAX_MEMORY_CHARS)
+        bullets.shift();
+    await fs.writeFile(file, bullets.join('\n') + '\n', 'utf8');
+}
+/** Format rules+memory as an injectable block (mirrors the IDE injection). */
+export function contextBlock(ctx) {
+    const parts = [];
+    if (ctx.rules)
+        parts.push(`PROJECT RULES (from .oioxo/rules.md — always follow these):\n${ctx.rules}`);
+    if (ctx.memory)
+        parts.push(`PROJECT MEMORY (facts OIOXO learned about this project, on-device):\n${ctx.memory}`);
+    return parts.join('\n\n');
+}

package/dist/core/skeleton.d.ts

@@ -0,0 +1,21 @@
+/**
+ * OIOXO skeletonizer — the API surface of a file without implementation bodies.
+ * Returning signatures instead of bodies is where most of the token saving
+ * comes from: the agent learns WHAT exists and how to call it for ~5-10% of the
+ * tokens of the full file, and only pulls full bodies for the files it edits.
+ *
+ * Regex-based (no parser dependency) across the common languages, tuned for
+ * top-level declarations. Good-enough by design — when a signature is missed
+ * the agent simply falls back to reading the file.
+ */
+export interface SymbolSig {
+    file: string;
+    name: string;
+    kind: string;
+    signature: string;
+    line: number;
+}
+/** Extract top-level-ish declarations from one file. */
+export declare function extractSignatures(path: string, content: string, maxPerFile?: number): SymbolSig[];
+/** A compact skeleton block for one file: path header + signatures only. */
+export declare function fileSkeleton(path: string, content: string): string;

package/dist/core/skeleton.js

@@ -0,0 +1,106 @@
+/**
+ * OIOXO skeletonizer — the API surface of a file without implementation bodies.
+ * Returning signatures instead of bodies is where most of the token saving
+ * comes from: the agent learns WHAT exists and how to call it for ~5-10% of the
+ * tokens of the full file, and only pulls full bodies for the files it edits.
+ *
+ * Regex-based (no parser dependency) across the common languages, tuned for
+ * top-level declarations. Good-enough by design — when a signature is missed
+ * the agent simply falls back to reading the file.
+ */
+const TSJS = {
+    test: /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/,
+    patterns: [
+        { re: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*(?<name>[A-Za-z_$][\w$]*)\s*(?:<[^>]*>)?\([^)]*\)?[^{;]*/, kind: 'function' },
+        { re: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(?<name>[A-Za-z_$][\w$]*)[^{]*/, kind: 'class' },
+        { re: /^\s*(?:export\s+)?interface\s+(?<name>[A-Za-z_$][\w$]*)[^{]*/, kind: 'interface' },
+        { re: /^\s*(?:export\s+)?type\s+(?<name>[A-Za-z_$][\w$]*)\s*=?.*/, kind: 'type' },
+        { re: /^\s*(?:export\s+)?enum\s+(?<name>[A-Za-z_$][\w$]*).*/, kind: 'enum' },
+        { re: /^\s*export\s+(?:const|let|var)\s+(?<name>[A-Za-z_$][\w$]*)\s*(?::[^=]+)?=?.*/, kind: 'const' },
+    ],
+};
+const PYTHON = {
+    test: /\.py$/,
+    patterns: [
+        { re: /^\s*(?:async\s+)?def\s+(?<name>\w+)\s*\([^)]*\)?[^:]*/, kind: 'function' },
+        { re: /^\s*class\s+(?<name>\w+).*/, kind: 'class' },
+    ],
+};
+const GO = {
+    test: /\.go$/,
+    patterns: [
+        { re: /^\s*func\s+(?:\([^)]+\)\s*)?(?<name>\w+)\s*\([^)]*\)?[^{]*/, kind: 'func' },
+        { re: /^\s*type\s+(?<name>\w+)\s+(?:struct|interface).*/, kind: 'type' },
+    ],
+};
+const RUST = {
+    test: /\.rs$/,
+    patterns: [
+        { re: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(?<name>\w+)\s*(?:<[^>]*>)?\([^)]*\)?[^{]*/, kind: 'fn' },
+        { re: /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+(?<name>\w+).*/, kind: 'type' },
+        { re: /^\s*impl(?:<[^>]*>)?\s+(?<name>[\w:]+).*/, kind: 'impl' },
+    ],
+};
+const CLIKE = {
+    test: /\.(java|cs|kt|swift|c|h|cpp|php|rb)$/,
+    patterns: [
+        { re: /^\s*(?:public|private|protected|internal|static|final|abstract|override|\s)*\s*(?:class|interface|struct|enum|trait|module)\s+(?<name>\w+).*/, kind: 'class' },
+        { re: /^\s*(?:public|private|protected|internal|static|final|virtual|override|async|func|def|\s)+[\w<>\[\],\s*&]*?\b(?<name>\w+)\s*\([^)]*\)?\s*[^{;]*/, kind: 'method' },
+    ],
+};
+const RULES = [TSJS, PYTHON, GO, RUST, CLIKE];
+const clean = (s) => s.replace(/\s+/g, ' ').trim().slice(0, 240);
+/** Extract top-level-ish declarations from one file. */
+export function extractSignatures(path, content, maxPerFile = 80) {
+    const rule = RULES.find((r) => r.test.test(path));
+    if (!rule)
+        return [];
+    const out = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length && out.length < maxPerFile; i++) {
+        const line = lines[i];
+        if (!line.trim() || line.trim().startsWith('//') || line.trim().startsWith('#') || line.trim().startsWith('*'))
+            continue;
+        for (const { re, kind } of rule.patterns) {
+            const m = re.exec(line);
+            const name = m?.groups?.name;
+            if (m && name) {
+                // For multi-line signatures, pull continuation lines until ')' balance or 3 lines.
+                let sig = line;
+                if (sig.includes('(') && !sig.includes(')')) {
+                    for (let j = i + 1; j < Math.min(i + 4, lines.length); j++) {
+                        sig += ' ' + lines[j];
+                        if (lines[j].includes(')'))
+                            break;
+                    }
+                }
+                // Cut the body: everything before the first '{' (or trailing ':').
+                const brace = sig.indexOf('{');
+                if (brace > 0)
+                    sig = sig.slice(0, brace);
+                out.push({ file: path, name, kind, signature: clean(sig), line: i + 1 });
+                break;
+            }
+        }
+    }
+    // De-dup (overloads / pattern overlap) by name+line.
+    const seen = new Set();
+    return out.filter((s) => {
+        const key = `${s.name}:${s.line}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** A compact skeleton block for one file: path header + signatures only. */
+export function fileSkeleton(path, content) {
+    const sigs = extractSignatures(path, content);
+    if (!sigs.length) {
+        // Non-code or nothing matched: head excerpt is better than nothing for
+        // configs/docs, still far cheaper than the full file.
+        const head = content.split('\n').slice(0, 12).join('\n');
+        return `// ${path} (excerpt)\n${head}`;
+    }
+    return `// ${path} — API surface (bodies omitted)\n${sigs.map((s) => `${s.kind} ${s.signature}  [L${s.line}]`).join('\n')}`;
+}

package/dist/gate/account.d.ts

@@ -0,0 +1,32 @@
+export declare const CONTROL_PLANE: string;
+export interface StoredCredentials {
+    token: string;
+    /** Epoch ms the bearer expires. */
+    expiresAt: number;
+    device: string;
+    email?: string;
+}
+export declare function readCredentials(): Promise<StoredCredentials | null>;
+export declare function writeCredentials(creds: StoredCredentials): Promise<void>;
+export declare function clearCredentials(): Promise<void>;
+/** Stable per-machine device id (persisted beside the credentials). */
+export declare function deviceId(): Promise<string>;
+/** Mirror of the backend's SaveState (lib/usage/save.ts). */
+export interface SaveState {
+    optimize: boolean;
+    unlimited: boolean;
+    tier: 'anon' | 'free' | 'pro';
+    savedThisMonth: number;
+    capTokens: number | null;
+    remainingTokens: number | null;
+    resetsAt: string;
+}
+/**
+ * Ask the server whether the engine may run; optionally report saved tokens
+ * first. Returns null on network failure (caller decides the message).
+ */
+export declare function saveMeter(action: 'check' | 'report', savedTokens?: number): Promise<SaveState | null>;
+/** True when a non-expired bearer is stored (NOT a plan check — server does that). */
+export declare function isLoggedIn(): Promise<boolean>;
+export declare const UPGRADE_URL = "https://oioxo.com/?upgrade=pro";
+export declare const LOGIN_HINT = "Run `oioxo-mcp login` in a terminal to connect your OIOXO account.";

package/dist/gate/account.js

@@ -0,0 +1,97 @@
+/**
+ * OIOXO account + plan gate for the MCP context engine.
+ *
+ * The #1 platform rule applies here too: PERMISSION LIVES ON THE SERVER. This
+ * module only (a) stores the 30-day device bearer that `oioxo-mcp login` minted
+ * via oioxo.com, and (b) asks the existing server-authoritative save-tokens
+ * meter (/api/usage/save) whether the engine may run and reports what it saved.
+ * A patched client can lie to itself but the server's running total decides:
+ *   anon  → engine off (sign in)            [registered-user feature]
+ *   free  → monthly saved-tokens allowance  [taste → upgrade]
+ *   pro   → unlimited
+ *
+ * Network failures FAIL TOWARD THE GATE for 'check' (no free-riding offline)
+ * but never crash the agent: tools degrade to a clear OIOXO message.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { randomBytes } from 'node:crypto';
+export const CONTROL_PLANE = process.env.OIOXO_CONTROL_PLANE?.replace(/\/$/, '') || 'https://oioxo.com';
+// OIOXO_HOME override keeps tests hermetic and lets ops relocate credentials.
+const HOME_DIR = process.env.OIOXO_HOME || path.join(os.homedir(), '.oioxo');
+const CREDS_FILE = path.join(HOME_DIR, 'credentials.json');
+export async function readCredentials() {
+    try {
+        const raw = JSON.parse(await fs.readFile(CREDS_FILE, 'utf8'));
+        return raw?.token ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCredentials(creds) {
+    await fs.mkdir(HOME_DIR, { recursive: true });
+    await fs.writeFile(CREDS_FILE, JSON.stringify(creds, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+export async function clearCredentials() {
+    try {
+        await fs.unlink(CREDS_FILE);
+    }
+    catch { /* already gone */ }
+}
+/** Stable per-machine device id (persisted beside the credentials). */
+export async function deviceId() {
+    const existing = await readCredentials();
+    if (existing?.device)
+        return existing.device;
+    try {
+        const raw = await fs.readFile(path.join(HOME_DIR, 'device'), 'utf8');
+        if (raw.trim())
+            return raw.trim();
+    }
+    catch { /* mint below */ }
+    const id = randomBytes(16).toString('base64url');
+    await fs.mkdir(HOME_DIR, { recursive: true });
+    await fs.writeFile(path.join(HOME_DIR, 'device'), id, 'utf8');
+    return id;
+}
+async function authHeaders() {
+    const creds = await readCredentials();
+    const device = await deviceId();
+    const h = {
+        'content-type': 'application/json',
+        // First-party non-browser client — same self-declaration the desktop uses.
+        'x-oioxo-client': 'desktop',
+        'x-oioxo-device': device,
+    };
+    if (creds?.token && creds.expiresAt > Date.now())
+        h.authorization = `Bearer ${creds.token}`;
+    return h;
+}
+/**
+ * Ask the server whether the engine may run; optionally report saved tokens
+ * first. Returns null on network failure (caller decides the message).
+ */
+export async function saveMeter(action, savedTokens) {
+    try {
+        const res = await fetch(`${CONTROL_PLANE}/api/usage/save`, {
+            method: 'POST',
+            headers: await authHeaders(),
+            body: JSON.stringify(action === 'report' ? { action, savedTokens } : { action }),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+/** True when a non-expired bearer is stored (NOT a plan check — server does that). */
+export async function isLoggedIn() {
+    const creds = await readCredentials();
+    return !!creds && creds.expiresAt > Date.now();
+}
+export const UPGRADE_URL = 'https://oioxo.com/?upgrade=pro';
+export const LOGIN_HINT = 'Run `oioxo-mcp login` in a terminal to connect your OIOXO account.';

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * oioxo-mcp — OIOXO context engine for AI coding agents.
+ * Public programmatic API (the CLI/MCP server are the primary surfaces).
+ */
+export { loadProject, listProjectFiles, readProjectFile, type ProjectFile } from './core/files.js';
+export { Bm25Index, tokenize, type RetrievedChunk, type IndexStatus } from './core/bm25.js';
+export { buildGraph, expandContext, importSpecifiers, resolveImport, type CodeGraph } from './core/code-graph.js';
+export { extractSignatures, fileSkeleton, type SymbolSig } from './core/skeleton.js';
+export { buildCapsule, type Capsule, type CapsuleOptions } from './core/capsule.js';
+export { readProjectContext, rememberFact, contextBlock, OIOXO_DIR } from './core/memory.js';
+export { startServer } from './mcp/server.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * oioxo-mcp — OIOXO context engine for AI coding agents.
+ * Public programmatic API (the CLI/MCP server are the primary surfaces).
+ */
+export { loadProject, listProjectFiles, readProjectFile } from './core/files.js';
+export { Bm25Index, tokenize } from './core/bm25.js';
+export { buildGraph, expandContext, importSpecifiers, resolveImport } from './core/code-graph.js';
+export { extractSignatures, fileSkeleton } from './core/skeleton.js';
+export { buildCapsule } from './core/capsule.js';
+export { readProjectContext, rememberFact, contextBlock, OIOXO_DIR } from './core/memory.js';
+export { startServer } from './mcp/server.js';

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare function startServer(root: string): Promise<void>;