offgrid-ai 0.1.2

package/src/profiles.mjs

@@ -0,0 +1,165 @@
+import { existsSync, statSync } from "node:fs";
+import { mkdir, readdir, rm, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { PROFILE_DIR, RUN_DIR, LOG_DIR } from "./config.mjs";
+import { backendFor } from "./backends.mjs";
+import { readJson, writeJson } from "./json.mjs";
+
+// ── Path helpers ───────────────────────────────────────────────────────────
+
+export function profileDir(id) {
+  return join(PROFILE_DIR, sanitizeProfileId(id));
+}
+
+export function profileJsonPath(id) {
+  return join(profileDir(id), "profile.json");
+}
+
+export function commandJsonPath(id) {
+  return join(profileDir(id), "command.json");
+}
+
+export function notesPath(id) {
+  return join(profileDir(id), "notes.md");
+}
+
+export function statePath(id) {
+  return join(RUN_DIR, `${sanitizeProfileId(id)}.state.json`);
+}
+
+export function profileExists(id) {
+  return existsSync(profileJsonPath(id));
+}
+
+export function sanitizeProfileId(value) {
+  return String(value).trim().toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-|-$/gu, "") || "profile";
+}
+
+export function slugFromLabel(value) {
+  return sanitizeProfileId(value);
+}
+
+// ── CRUD ───────────────────────────────────────────────────────────────────
+
+export async function loadProfiles() {
+  const entries = await readdir(PROFILE_DIR, { withFileTypes: true }).catch(() => []);
+  const ids = entries
+    .filter((e) => e.isDirectory() && existsSync(profileJsonPath(e.name)))
+    .map((e) => e.name)
+    .sort();
+  return Promise.all(ids.map((id) => readProfile(id)));
+}
+
+export async function readProfile(id) {
+  const path = profileJsonPath(id);
+  if (!existsSync(path)) throw new Error(`Profile "${id}" not found.`);
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+export async function saveProfile(profile) {
+  const id = sanitizeProfileId(profile.id);
+  const dir = profileDir(id);
+  await mkdir(dir, { recursive: true });
+  const now = new Date().toISOString();
+  const existing = await readJsonIfExists(profileJsonPath(id), null);
+  const saved = {
+    ...profile,
+    id,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+  };
+  await writeJson(profileJsonPath(id), saved);
+
+  // Write JSON command file for llama-server backends
+  const backend = backendFor(saved.backend);
+  if (backend.needsCommandFile) {
+    const cmdPath = commandJsonPath(id);
+    if (!existsSync(cmdPath)) {
+      await writeJson(cmdPath, { argv: saved.commandArgv ?? saved.flags ?? [] });
+    }
+  }
+
+  if (!existsSync(notesPath(id))) {
+    await writeFile(notesPath(id), `# ${saved.label}\n\nNotes for this model profile.\n`, "utf8");
+  }
+  return saved;
+}
+
+export async function deleteProfile(id, options = {}) {
+  const dir = profileDir(id);
+  const results = { profileDir: false, state: false, logs: [] };
+  if (existsSync(dir)) {
+    await rm(dir, { recursive: true, force: true });
+    results.profileDir = true;
+  }
+  const stateFile = statePath(id);
+  if (existsSync(stateFile)) {
+    await unlink(stateFile);
+    results.state = true;
+  }
+  if (!options.keepLogs) {
+    const entries = await readdir(LOG_DIR, { withFileTypes: true }).catch(() => []);
+    const prefix = `${sanitizeProfileId(id)}-`;
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.startsWith(prefix)) {
+        await unlink(join(LOG_DIR, entry.name));
+        results.logs.push(entry.name);
+      }
+    }
+  }
+  return results;
+}
+
+// ── Normalize / auto-detect ────────────────────────────────────────────────
+
+export function normalizeProfile(profile, modelPath, mmprojPath) {
+  const backend = backendFor(profile.backend);
+  const flags = {
+    host: "127.0.0.1",
+    port: backend.defaultPort,
+    ...profile.flags,
+  };
+  if (!profile.baseUrl) {
+    profile.baseUrl = `http://${flags.host}:${flags.port}/v1`;
+  }
+
+  return {
+    ...profile,
+    flags,
+    providerId: profile.providerId ?? backend.providerId,
+    harnesses: profile.harnesses ?? {
+      pi: { enabled: true, model: `${profile.providerId ?? backend.providerId}/${profile.modelAlias ?? profile.id}` },
+    },
+  };
+}
+
+// ── Auto-create profile from a discovered model ────────────────────────────
+
+export async function createProfileFromModel(model, backendId = "llama-cpp") {
+  const { detectCapabilities } = await import("./autodetect.mjs");
+  const caps = detectCapabilities(model.path, model.mmprojPath);
+  const id = slugFromLabel(model.label);
+  const { flags, argv } = computeFlags(caps, model.path, model.mmprojPath, null);
+
+  return normalizeProfile({
+    id,
+    label: model.label,
+    backend: backendId,
+    modelAlias: model.aliasSuggestion,
+    modelPath: model.path,
+    mmprojPath: model.mmprojPath,
+    preset: null, // no presets — auto-detected
+    flags,
+    commandArgv: argv,
+  }, model.path, model.mmprojPath);
+}
+
+// ── State files (for running servers) ──────────────────────────────────────
+
+export async function readState(id) {
+  return readJson(statePath(id), null);
+}
+
+export async function writeState(id, state) {
+  await writeJson(statePath(id), state);
+}

package/src/scan.mjs

@@ -0,0 +1,78 @@
+import { statSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getModelScanDirs } from "./config.mjs";
+
+export async function scanGgufModels(dirs) {
+  const scanDirs = dirs ?? await getModelScanDirs();
+  const allModels = [];
+
+  for (const root of scanDirs) {
+    const models = await scanOneDir(root);
+    allModels.push(...models);
+  }
+
+  // Deduplicate by path
+  const seen = new Set();
+  return allModels.filter((m) => {
+    if (seen.has(m.path)) return false;
+    seen.add(m.path);
+    return true;
+  }).sort((a, b) => a.label.localeCompare(b.label));
+}
+
+async function scanOneDir(root) {
+  const files = await findFiles(root, (path) => path.toLowerCase().endsWith(".gguf"));
+  const mmprojs = files.filter((path) => basename(path).toLowerCase().includes("mmproj"));
+  const models = files.filter((path) => !basename(path).toLowerCase().includes("mmproj"));
+
+  return models.map((path) => {
+    const dir = dirname(path);
+    const mmprojPath = mmprojs.find((candidate) => dirname(candidate) === dir) ?? null;
+    const name = basename(path).replace(/\.gguf$/i, "");
+    return {
+      path,
+      mmprojPath,
+      label: labelFromName(name),
+      aliasSuggestion: aliasFromName(name),
+      quant: quantFromName(name),
+      sizeBytes: statSync(path).size,
+      backend: "llama-cpp",
+      source: "local-gguf",
+    };
+  });
+}
+
+async function findFiles(root, predicate) {
+  const result = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) await walk(path);
+      else if (entry.isFile() && predicate(path)) result.push(path);
+    }
+  }
+  await walk(root);
+  return result;
+}
+
+function labelFromName(name) {
+  return name
+    .replace(/-/g, " ")
+    .replace(/\bqwen/i, "Qwen")
+    .replace(/q4_k_m/i, "Q4_K_M");
+}
+
+function aliasFromName(name) {
+  return name.replace(/-Q4_K_M$/i, "-GGUF");
+}
+
+function quantFromName(name) {
+  return name.match(/(Q\d_K_[A-Z]+|UD-[A-Z0-9_]+)/)?.[1];
+}

package/src/ui.mjs

@@ -0,0 +1,102 @@
+import { cancel, confirm, intro, isCancel, select, text } from "@clack/prompts";
+import pc from "picocolors";
+
+export { pc };
+export { pc as colors };
+
+export function printHelp() {
+  console.log(`${pc.bold("offgrid-ai")} — privacy-first local LLM runner\n`);
+  console.log("Usage:");
+  console.log("  offgrid-ai              Pick a model and run");
+  console.log("  offgrid-ai models       List profiles and models");
+  console.log("  offgrid-ai run [id]     Run a profile (start server + launch Pi)");
+  console.log("  offgrid-ai stop [id]    Stop a running server");
+  console.log("  offgrid-ai benchmark    Run a benchmark prompt");
+  console.log("");
+  console.log(pc.bold("Run modes (--with):"));
+  console.log("  pi        Launch Pi with the selected model (default)");
+  console.log("  server    Start server only, no harness");
+}
+
+export function formatBytes(bytes) {
+  if (!Number.isFinite(bytes)) return "unknown";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unit = 0;
+  while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit += 1; }
+  return `${size.toFixed(unit === 0 ? 0 : 2)} ${units[unit]}`;
+}
+
+export function startInteractive(title = "offgrid-ai") {
+  if (process.stdin.isTTY) console.clear();
+  intro(title);
+}
+
+export function createPrompt() {
+  return {
+    async text(label, defaultValue) {
+      const value = await text({ message: label, initialValue: defaultValue === undefined ? undefined : String(defaultValue) });
+      return handleCancel(value)?.trim() || String(defaultValue ?? "");
+    },
+    async number(label, defaultValue, min, max) {
+      const value = await text({
+        message: label, initialValue: String(defaultValue),
+        validate(input) { const n = Number(input); if (!Number.isFinite(n) || n < min || n > max) return `Enter a number from ${min} to ${max}.`; },
+      });
+      return Number(handleCancel(value));
+    },
+    async yesNo(label, defaultValue) {
+      return handleCancel(await confirm({ message: label, initialValue: defaultValue }));
+    },
+    async choice(label, choices, defaultValue) {
+      return handleCancel(await select({
+        message: label, initialValue: defaultValue,
+        options: choices.map((c) => ({ value: c.value, label: c.label ?? c.value, hint: c.hint })),
+      }));
+    },
+    close() {},
+  };
+}
+
+function handleCancel(value) {
+  if (isCancel(value)) { cancel("Cancelled."); process.exit(0); }
+  return value;
+}
+
+export function relativeTime(date) {
+  const ms = Date.now() - date.getTime();
+  const abs = Math.abs(ms);
+  for (const [label, size] of [["day", 86400000], ["hour", 3600000], ["minute", 60000], ["second", 1000]]) {
+    if (abs >= size) { const v = Math.round(abs / size); return `${v} ${label}${v === 1 ? "" : "s"} ago`; }
+  }
+  return "just now";
+}
+
+export function renderRows(rows) {
+  const width = Math.max(...rows.map(([key]) => pc.strip(String(key)).length));
+  return rows.map(([key, value]) => {
+    const visible = pc.strip(String(key)).length;
+    return `${key}${" ".repeat(Math.max(1, width - visible + 2))}${value}`;
+  }).join("\n");
+}
+
+export function renderSection(title, body) {
+  return `${pc.magenta("◆")} ${pc.bold(title)}\n${body}`;
+}
+
+export function parseOptions(argv) {
+  const positional = [];
+  const options = {};
+  for (let i = 0; i < argv.length; i++) {
+    const item = argv[i];
+    if (item.startsWith("--")) {
+      const key = item.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) { options[key] = next; i += 1; }
+      else options[key] = true;
+    } else {
+      positional.push(item);
+    }
+  }
+  return { positional, options };
+}