@mandujs/core 0.45.1 → 0.46.0

package/src/brain/adapters/openai-oauth.ts

@@ -45,7 +45,7 @@ import type {
   CompletionResult,
 } from "../types";
 import type {
-  CredentialStore} from "../credentials";
+  CredentialStore} from "../credentials";
 import {
   getCredentialStore,
   type StoredToken,
@@ -89,10 +89,8 @@ export const OPENAI_OAUTH_SCOPE = "openai.chat";
 /**
  * Default model — GPT-5.4 (current-generation OpenAI flagship as of
  * 2026-04). Gives brain doctor triage the quality it needs to produce
- * actionable patches, which was the whole motivation for moving off
- * the local ministral-3:3b adapter. Override via
- * `ManduConfig.brain.openai.model` (e.g. set to a cheaper tier for
- * low-stakes automated runs).
+ * actionable patches. Override via `ManduConfig.brain.openai.model`
+ * (e.g. set to a cheaper tier for low-stakes automated runs).
  */
 export const OPENAI_DEFAULT_MODEL = "gpt-5.4";
 export const OPENAI_API_BASE = "https://api.openai.com/v1";

package/src/brain/brain.ts

@@ -20,8 +20,7 @@ import type {
 } from "./types";
 import { DEFAULT_BRAIN_POLICY } from "./types";
 import { type LLMAdapter, NoopAdapter } from "./adapters/base";
-import { createOllamaAdapter } from "./adapters/ollama";
-import type { SessionMemory} from "./memory";
+import type { SessionMemory} from "./memory";
 import { getSessionMemory } from "./memory";
 import {
   detectEnvironment,
@@ -96,15 +95,13 @@ export class Brain {
       ...options.config,
     };
 
-    // Set up adapter
-    if (options.adapter) {
-      this.adapter = options.adapter;
-    } else if (this.config.adapter) {
-      this.adapter = createOllamaAdapter(this.config.adapter);
-    } else {
-      // Default: Ollama with default settings
-      this.adapter = createOllamaAdapter();
-    }
+    // Set up adapter — sync default is NoopAdapter (template). The CLI
+    // constructs Brain with `options.adapter` populated by
+    // `resolveBrainAdapter()` so cloud tiers reach Brain. Surfaces that
+    // skip that resolver (server runtime, server-side imports of Brain)
+    // get the safe template fallback. Issue #235 removed the local
+    // Ollama tier; cloud OAuth is the only non-template adapter now.
+    this.adapter = options.adapter ?? new NoopAdapter();
 
     // Get session memory
     this.memory = getSessionMemory();

package/src/brain/consent.ts

@@ -13,7 +13,7 @@
  *
  * Privacy invariants:
  *   - If consent is not granted, the adapter MUST fall through to the
- *     next tier in the resolver (ollama → template).
+ *     template tier in the resolver (NoopAdapter).
  *   - `telemetryOptOut: true` in config bypasses this module entirely —
  *     cloud adapters are never constructed in that case.
  *   - The consent cache only stores `{ providerId, projectFingerprint,

package/src/brain/index.ts

@@ -10,8 +10,11 @@
 // Types
 export * from "./types";
 
-// Adapters (includes Ollama, OpenAI OAuth, Anthropic OAuth, and the
+// Adapters (OpenAI OAuth, Anthropic OAuth, plus the
 // `createBrainAdapter` / `resolveBrainAdapter` resolver — Issue #235).
+// The local Ollama tier was removed; cloud OAuth is the only non-template
+// adapter now. Interactive CLIs prompt `mandu brain login` when the
+// resolver returns `needsLogin: true`.
 export * from "./adapters";
 
 // Credential store (OS keychain + filesystem fallback).

package/src/config/mandu.ts

@@ -644,20 +644,19 @@ export interface ManduConfig {
    * Fields:
    *   - `adapter`          — Which connector to use. Default `"auto"`.
    *                          Auto resolves in priority order:
-   *                          openai → anthropic → ollama → template.
-   *                          Explicit values pin the choice but still
-   *                          degrade to template when the dependency is
-   *                          unreachable (no hard failures).
-   *   - `openai.model`     — Override the OpenAI model (default
-   *                          `"gpt-4o-mini"`).
-   *   - `anthropic.model`  — Override the Anthropic model (default
-   *                          `"claude-haiku-4-5-20251001"`).
-   *   - `ollama.model`     — Override the local Ollama model (default
-   *                          `"ministral-3:3b"`).
+   *                          openai → anthropic → template. Explicit
+   *                          values pin the choice but still degrade
+   *                          to template when the dependency is
+   *                          unreachable (no hard failures). Interactive
+   *                          CLIs prompt `mandu brain login` when the
+   *                          fallback fires due to a missing token.
+   *   - `openai.model`     — Override the OpenAI model.
+   *   - `anthropic.model`  — Override the Anthropic model.
    *   - `telemetryOptOut`  — When `true`, cloud adapters are disabled
    *                          entirely regardless of stored tokens. The
-   *                          resolver falls to ollama/template. Use for
-   *                          privacy-strict environments.
+   *                          resolver falls to template silently (no
+   *                          login prompt). Use for privacy-strict
+   *                          environments.
    *
    * Omitting this block is equivalent to `{ adapter: "auto" }`.
    *
@@ -665,10 +664,9 @@ export interface ManduConfig {
    * @see `docs/brain/oauth-adapters.md` (when authored).
    */
   brain?: {
-    adapter?: "auto" | "openai" | "anthropic" | "ollama" | "template";
+    adapter?: "auto" | "openai" | "anthropic" | "template";
     openai?: { model?: string };
     anthropic?: { model?: string };
-    ollama?: { model?: string; baseUrl?: string };
     telemetryOptOut?: boolean;
   };
   /**

package/src/config/validate.ts

@@ -663,21 +663,13 @@ const BrainAnthropicConfigSchema = z
   })
   .strict();
 
-const BrainOllamaConfigSchema = z
-  .object({
-    model: z.string().min(1).optional(),
-    baseUrl: z.string().url().optional(),
-  })
-  .strict();
-
 const BrainConfigSchema = z
   .object({
     adapter: z
-      .enum(["auto", "openai", "anthropic", "ollama", "template"])
+      .enum(["auto", "openai", "anthropic", "template"])
       .default("auto"),
     openai: BrainOpenAIConfigSchema.optional(),
     anthropic: BrainAnthropicConfigSchema.optional(),
-    ollama: BrainOllamaConfigSchema.optional(),
     telemetryOptOut: z.boolean().optional(),
   })
   .strict();
@@ -742,7 +734,8 @@ export const ManduConfigSchema = z
      * Issue #235 — Brain adapter selection. See {@link BrainConfigSchema}.
      * Optional; omission is equivalent to `{ adapter: "auto" }`, which
      * resolves in priority order: openai-oauth → anthropic-oauth →
-     * ollama → template.
+     * template (with `needsLogin: true` so interactive CLIs prompt
+     * `mandu brain login`).
      */
     brain: BrainConfigSchema.optional(),
     /**

package/src/deploy/cache.ts

@@ -0,0 +1,139 @@
+/**
+ * Deploy intent cache — `.mandu/deploy.intent.json`.
+ *
+ * Issue #250 — Phase 1.
+ *
+ * The cache is the persistence layer between `mandu deploy:plan`
+ * (writer) and `mandu deploy --target=...` (reader). It MUST be
+ * checked into the repo so deploys are deterministic, brain-free, and
+ * reproducible across CI runs.
+ *
+ * Per-entry shape:
+ *
+ *   - `intent`     — fully validated `DeployIntent`.
+ *   - `source`     — `"explicit"` (user wrote `.deploy()` on the
+ *                    route) or `"inferred"` (heuristic / brain).
+ *                    Explicit entries are never overwritten by
+ *                    `deploy:plan` — the inferer treats them as
+ *                    pinned ground truth.
+ *   - `rationale`  — short, human-readable reason. The plan command
+ *                    surfaces this in the diff so reviewers can audit
+ *                    why a route landed on a given runtime.
+ *   - `sourceHash` — content hash of the route source the intent was
+ *                    inferred from. The next plan call skips
+ *                    re-inference when the hash matches — that's the
+ *                    cost cap on brain calls.
+ *   - `inferredAt` — ISO timestamp; left unset on `explicit` entries.
+ */
+
+import { z } from "zod";
+import { promises as fs } from "fs";
+import path from "path";
+import { DeployIntent } from "./intent";
+
+export const DeployIntentSource = z.enum(["explicit", "inferred"]);
+export type DeployIntentSource = z.infer<typeof DeployIntentSource>;
+
+export const DeployIntentCacheEntry = z.object({
+  intent: DeployIntent,
+  source: DeployIntentSource,
+  rationale: z.string().min(1),
+  sourceHash: z.string().min(1),
+  inferredAt: z.string().datetime().optional(),
+});
+export type DeployIntentCacheEntry = z.infer<typeof DeployIntentCacheEntry>;
+
+export const DeployIntentCache = z.object({
+  /** Format version — bump on any breaking schema change. */
+  version: z.literal(1),
+  /** ISO timestamp of the most recent `deploy:plan` write. */
+  generatedAt: z.string().datetime(),
+  /**
+   * Identifier of the inferer used for the most recent write. Examples:
+   *   - `"heuristic"`              — rule-tree only (no brain).
+   *   - `"openai:gpt-4.1-mini"`    — brain-validated.
+   *   - `"manual"`                 — user hand-edited entries.
+   */
+  brainModel: z.string().min(1).default("heuristic"),
+  /** Map of route id → cache entry. */
+  intents: z.record(z.string(), DeployIntentCacheEntry),
+});
+export type DeployIntentCache = z.infer<typeof DeployIntentCache>;
+
+/** Filename relative to the project root. */
+export const DEPLOY_INTENT_CACHE_FILE = ".mandu/deploy.intent.json";
+
+/** Resolve the absolute path of the cache file for a given project root. */
+export function resolveDeployIntentCachePath(rootDir: string): string {
+  return path.join(rootDir, DEPLOY_INTENT_CACHE_FILE);
+}
+
+/**
+ * An empty (but valid) cache. Returned by `loadDeployIntentCache`
+ * when the file is missing — the caller treats that as "every route
+ * needs inference".
+ */
+export function emptyDeployIntentCache(): DeployIntentCache {
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    brainModel: "heuristic",
+    intents: {},
+  };
+}
+
+/**
+ * Read + validate the cache file. A missing file resolves to an empty
+ * cache so first-time runs work without ceremony. A malformed file
+ * rejects — silently swallowing JSON errors would let a corrupted
+ * cache silently produce wrong deploy configs.
+ */
+export async function loadDeployIntentCache(
+  rootDir: string,
+): Promise<DeployIntentCache> {
+  const file = resolveDeployIntentCachePath(rootDir);
+  let raw: string;
+  try {
+    raw = await fs.readFile(file, "utf8");
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return emptyDeployIntentCache();
+    }
+    throw err;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Deploy intent cache is not valid JSON (${file}): ${(err as Error).message}`,
+    );
+  }
+  return DeployIntentCache.parse(parsed);
+}
+
+/**
+ * Atomically write the cache. The intermediate `.tmp` file + rename
+ * dance prevents a half-written cache from being read by a concurrent
+ * deploy.
+ */
+export async function saveDeployIntentCache(
+  rootDir: string,
+  cache: DeployIntentCache,
+): Promise<void> {
+  const validated = DeployIntentCache.parse(cache);
+  const file = resolveDeployIntentCachePath(rootDir);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  // Stable key order so the committed file stays diff-friendly.
+  const ordered: DeployIntentCache = {
+    ...validated,
+    intents: Object.fromEntries(
+      Object.keys(validated.intents)
+        .sort()
+        .map((id) => [id, validated.intents[id]!]),
+    ),
+  };
+  await fs.writeFile(tmp, JSON.stringify(ordered, null, 2) + "\n", "utf8");
+  await fs.rename(tmp, file);
+}

package/src/deploy/index.ts

@@ -0,0 +1,62 @@
+/**
+ * `@mandujs/core/deploy` — deploy intent primitive (issue #250 Phase 1).
+ *
+ * The barrel re-exports everything adapters and the CLI need:
+ *
+ *   - **Schemas**: `DeployIntent`, `DeployIntentCache`, runtime / cache /
+ *     visibility / target enums, plus the partial `DeployIntentInput`
+ *     used by the `.deploy()` builder call site.
+ *   - **Cache I/O**: `loadDeployIntentCache`, `saveDeployIntentCache`,
+ *     `emptyDeployIntentCache`, the cache file path constants.
+ *   - **Inference**: the offline heuristic and the context builder. The
+ *     brain inferer plugs in via `planDeploy({ infer: ... })`.
+ *   - **Plan**: `planDeploy` returns the next cache + a diff in one
+ *     pure call.
+ *   - **Validation helpers**: `isStaticIntentValidFor` so adapters can
+ *     surface configuration errors before deploy.
+ */
+
+export {
+  DeployIntent,
+  DeployIntentInput,
+  DeployRuntime,
+  DeployCache,
+  DeployCacheLifetime,
+  DeployVisibility,
+  DeployTarget,
+  isStaticIntentValidFor,
+} from "./intent";
+
+export {
+  DeployIntentCache,
+  DeployIntentCacheEntry,
+  DeployIntentSource,
+  DEPLOY_INTENT_CACHE_FILE,
+  emptyDeployIntentCache,
+  loadDeployIntentCache,
+  saveDeployIntentCache,
+  resolveDeployIntentCachePath,
+} from "./cache";
+
+export {
+  buildDeployInferenceContext,
+  classifyImports,
+  extractImports,
+  hashSource,
+  type DependencyClass,
+  type DeployInferenceContext,
+} from "./inference/context";
+
+export {
+  inferDeployIntentHeuristic,
+  type InferenceResult,
+} from "./inference/heuristic";
+
+export {
+  planDeploy,
+  planHasChanges,
+  type PlanDeployOptions,
+  type PlanDiffEntry,
+  type PlanDiffEntryKind,
+  type PlanResult,
+} from "./plan";

package/src/deploy/inference/context.ts

@@ -0,0 +1,173 @@
+/**
+ * Deploy inference context — the bundle of facts an inferer (heuristic
+ * or brain) consumes when deciding a route's `DeployIntent`.
+ *
+ * Issue #250 — Phase 1.
+ *
+ * The context is intentionally narrow. Anything that's not statically
+ * derivable from the route source and manifest entry stays out — we
+ * want inference to be deterministic enough that two identical inputs
+ * always yield the same intent.
+ */
+
+import { promises as fs } from "fs";
+import { createHash } from "crypto";
+import path from "path";
+import type { RouteSpec } from "../../spec/schema";
+
+/**
+ * The dependency import classes the heuristic recognises. Mapped from
+ * raw import specifiers in `extractImports()` below. The key is the
+ * coarsest signal a route exposes about whether it can run at the
+ * edge — DB drivers and file IO push the route to `node`/`bun`, while
+ * stateless `fetch`/transform code happily runs at the edge.
+ */
+export type DependencyClass =
+  | "db"          // bun:sqlite, postgres, drizzle, prisma, mongodb, etc.
+  | "node-fs"    // node:fs, fs/promises, fs
+  | "node-net"   // node:net, http, dgram
+  | "node-child" // node:child_process, worker_threads
+  | "bun-native" // bun:sqlite, bun:ffi, Bun.s3, Bun.serve
+  | "ai-sdk"     // @anthropic-ai/sdk, openai, ai (long latency)
+  | "heavy"      // sharp, playwright, puppeteer, large native deps
+  | "fetch-only" // only http fetch / minor transforms
+  | "unknown";
+
+export interface DeployInferenceContext {
+  /** Stable id from the manifest entry. */
+  routeId: string;
+  /** URL pattern (`/api/embed`, `/[lang]/page`). */
+  pattern: string;
+  /** `page` | `api` | `metadata`. */
+  kind: RouteSpec["kind"];
+  /** Pattern contains `[param]` or `[...rest]`. */
+  isDynamic: boolean;
+  /**
+   * Page route exports `generateStaticParams` AND has at least one
+   * static-param entry in the manifest. Adapters use this with
+   * `runtime: "static"` to know the route is genuinely prerenderable.
+   */
+  hasGenerateStaticParams: boolean;
+  /** Top-level imports from the handler module (deduped, sorted). */
+  imports: string[];
+  /** Coarse classification derived from `imports`. */
+  dependencyClasses: ReadonlySet<DependencyClass>;
+  /** Whether the handler exports a `default` Mandu.filling() instance. */
+  exportsFilling: boolean;
+  /**
+   * SHA-256 of the route source. Used by the cache to skip re-
+   * inference when nothing relevant changed.
+   */
+  sourceHash: string;
+}
+
+/**
+ * Build the inference context for a single route. `rootDir` is the
+ * project root; `route.module` is resolved relative to it.
+ */
+export async function buildDeployInferenceContext(
+  rootDir: string,
+  route: RouteSpec,
+): Promise<DeployInferenceContext> {
+  const modulePath = path.resolve(rootDir, route.module);
+  let source = "";
+  try {
+    source = await fs.readFile(modulePath, "utf8");
+  } catch {
+    // A missing module file is unusual but not fatal — the inferer
+    // still gets the manifest metadata and falls back to defaults.
+  }
+
+  const imports = extractImports(source);
+  const dependencyClasses = classifyImports(imports);
+  const isDynamic = /\[(\.\.\.)?[^\]]+\]/.test(route.pattern);
+  const hasGenerateStaticParams =
+    route.kind === "page" &&
+    Array.isArray(route.staticParams) &&
+    route.staticParams.length > 0;
+  const exportsFilling = /\bMandu\.filling\b|\bfilling\(\)/m.test(source);
+
+  return {
+    routeId: route.id,
+    pattern: route.pattern,
+    kind: route.kind,
+    isDynamic,
+    hasGenerateStaticParams,
+    imports,
+    dependencyClasses,
+    exportsFilling,
+    sourceHash: hashSource(source),
+  };
+}
+
+// ─── Internals ────────────────────────────────────────────────────────
+
+/** SHA-256 hex digest. Empty input still produces a stable hash. */
+export function hashSource(source: string): string {
+  return createHash("sha256").update(source).digest("hex");
+}
+
+/**
+ * Extract bare import specifiers (`from "..."` / `import("...")`).
+ *
+ * Best-effort — a TS AST would be more precise but pulling in a parser
+ * just for this is heavy. False positives (matches in comments or
+ * strings) only mis-classify the route in the heuristic, never break
+ * deploys, and the brain inferer can override.
+ */
+export function extractImports(source: string): string[] {
+  const out = new Set<string>();
+  const staticImport = /^\s*import\b[^"']*?["']([^"']+)["']/gm;
+  const dynamicImport = /\bimport\(\s*["']([^"']+)["']\s*\)/g;
+  for (const re of [staticImport, dynamicImport]) {
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(source)) !== null) {
+      const spec = m[1]!;
+      if (!spec.startsWith(".")) out.add(spec);
+    }
+  }
+  return [...out].sort();
+}
+
+/** Map import specifiers to coarse dependency classes. */
+export function classifyImports(imports: string[]): ReadonlySet<DependencyClass> {
+  const classes = new Set<DependencyClass>();
+  for (const spec of imports) {
+    const cls = classifyOne(spec);
+    if (cls) classes.add(cls);
+  }
+  if (classes.size === 0) classes.add("fetch-only");
+  return classes;
+}
+
+function classifyOne(spec: string): DependencyClass | null {
+  const s = spec.toLowerCase();
+  if (
+    s === "bun:sqlite" ||
+    s === "bun:ffi" ||
+    s.startsWith("bun:")
+  ) {
+    return "bun-native";
+  }
+  if (s === "fs" || s === "fs/promises" || s === "node:fs" || s === "node:fs/promises" || s === "node:path") {
+    return "node-fs";
+  }
+  if (s === "net" || s === "node:net" || s === "node:dgram" || s === "node:tls") {
+    return "node-net";
+  }
+  if (s === "node:child_process" || s === "child_process" || s === "node:worker_threads" || s === "worker_threads") {
+    return "node-child";
+  }
+  if (
+    /^(postgres|pg|mysql2?|drizzle-orm(\/.*)?|@prisma\/client|prisma|mongodb|mongoose|@neondatabase\/.+|kysely|sqlite3|better-sqlite3|@planetscale\/.+)$/.test(s)
+  ) {
+    return "db";
+  }
+  if (/^(@anthropic-ai\/sdk|openai|ai|@ai-sdk\/.+|@google\/generative-ai|cohere-ai)$/.test(s)) {
+    return "ai-sdk";
+  }
+  if (/^(sharp|playwright|playwright-core|puppeteer|@sparticuz\/.+|canvas|jimp)$/.test(s)) {
+    return "heavy";
+  }
+  return null;
+}