@aitne-sh/aitne 0.1.0

package/scripts/commands/update.mjs

@@ -0,0 +1,96 @@
+/**
+ * `aitne update` — print the npm command to upgrade.
+ *
+ * No self-updater. Self-updaters break weirdly (permissions, registry
+ * redirects, partial writes) and npm already solves this. We only emit
+ * instructions; the user runs the command.
+ *
+ * Optional `--check` performs one short network call to compare against the
+ * latest published version. Default behavior is offline so the command stays
+ * fast and works on planes/trains.
+ */
+export async function run(args, ctx) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`Usage: aitne update [--check]
+
+Print the command to upgrade ${ctx.APP_NAME}. Does not actually upgrade —
+self-updaters fail in surprising ways, so the user runs the command.
+
+Flags:
+  --check        Make one network call to npm to fetch the latest version.
+                 Without --check, this command is offline.`);
+    return;
+  }
+
+  const cmd = `npm install -g ${packageNameForUpgrade()}@latest`;
+  console.log(`${ctx.APP_NAME} v${ctx.VERSION} is installed.`);
+  console.log("");
+  console.log("To upgrade:");
+  console.log("");
+  console.log(`    ${cmd}`);
+  console.log("");
+  console.log("After the upgraded daemon starts, bundled templates, docs, skills, and");
+  console.log("backend instruction caches are reconciled non-destructively. User-edited");
+  console.log("files are preserved and surfaced in the dashboard for review.");
+  console.log("");
+  console.log("Or run a one-shot session without installing:");
+  console.log("");
+  console.log(`    npx ${packageNameForUpgrade()}@latest start`);
+
+  if (args.includes("--check")) {
+    const latest = await fetchLatestVersion(packageNameForUpgrade());
+    if (latest) {
+      const cmp = compareSemver(ctx.VERSION, latest);
+      console.log("");
+      if (cmp < 0) {
+        console.log(`A newer version is available: ${latest} (current: ${ctx.VERSION}).`);
+      } else if (cmp === 0) {
+        console.log(`You are on the latest version (${latest}).`);
+      } else {
+        console.log(`You are ahead of the latest published version (${latest}).`);
+      }
+    } else {
+      console.log("");
+      console.log("(could not reach the npm registry — version check skipped)");
+    }
+  }
+}
+
+/**
+ * The published package name on npm. Hardcoded here rather than read from
+ * package.json so a maintainer who renames the in-repo package locally
+ * doesn't accidentally direct users to the wrong upgrade target.
+ */
+function packageNameForUpgrade() {
+  return "@aitne-sh/aitne";
+}
+
+async function fetchLatestVersion(name) {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 4000);
+    const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, {
+      signal: ctrl.signal,
+      headers: { Accept: "application/json" },
+    });
+    clearTimeout(t);
+    if (!res.ok) return null;
+    const body = await res.json();
+    return typeof body?.version === "string" ? body.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Tiny semver-ish comparator; returns -1 / 0 / 1. Pre-release tags ignored. */
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (da < db) return -1;
+    if (da > db) return 1;
+  }
+  return 0;
+}

package/scripts/commands/version.mjs

@@ -0,0 +1,62 @@
+/**
+ * `aitne version` — print version and execution environment.
+ *
+ * Detail beyond a bare semver helps when triaging install issues remotely
+ * ("what version of node, where is it installed, what platform?"). All of
+ * this is local-only — no network calls. For "is there a newer version?"
+ * use `aitne update` instead, which is opt-in.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { hasPackagedBuild } from "../run-node.mjs";
+
+export async function run(args, ctx) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`Usage: aitne version
+
+Print version, Node version, install path, and platform.
+
+This command is offline — to check for newer published versions, use
+\`aitne update\`.`);
+    return;
+  }
+
+  if (args.includes("--json")) {
+    const payload = collectVersion(ctx);
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+    return;
+  }
+
+  const v = collectVersion(ctx);
+  console.log(`${ctx.APP_NAME} v${v.version}`);
+  console.log("");
+  console.log(`  Node:        ${v.node}`);
+  console.log(`  Platform:    ${v.platform} (${v.arch})`);
+  console.log(`  Install:     ${v.installPath}`);
+  console.log(`  Data dir:    ${v.dataDir}`);
+  console.log(`  Build:       ${v.buildAt ?? (v.packagedBuild ? "packaged artifacts" : "(not built — run 'aitne build')")}`);
+}
+
+function collectVersion(ctx) {
+  let buildAt = null;
+  const stamp = path.join(ctx.PROJECT_ROOT, ".buildstamp");
+  if (fs.existsSync(stamp)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(stamp, "utf8"));
+      if (parsed?.builtAt) buildAt = new Date(parsed.builtAt).toISOString();
+    } catch { /* malformed stamp — treat as missing */ }
+  }
+  return {
+    name: ctx.APP_NAME,
+    version: ctx.VERSION,
+    node: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    installPath: ctx.PROJECT_ROOT,
+    dataDir: ctx.DATA_DIR,
+    homeDir: os.homedir(),
+    buildAt,
+    packagedBuild: buildAt == null && hasPackagedBuild(ctx.PROJECT_ROOT),
+  };
+}

package/scripts/lib/sqlite-loader.mjs

@@ -0,0 +1,49 @@
+/**
+ * Cross-context loader for better-sqlite3.
+ *
+ * The package ships as a daemon dependency. In two of our contexts it
+ * resolves at the top level via standard ESM:
+ *
+ *   1. After `npm install -g aitne` — the prepack flatten makes daemon
+ *      dependencies top-level for the published package, so `import`
+ *      resolves cleanly.
+ *   2. In the published package's tarball regardless of how it was
+ *      installed locally.
+ *
+ * In the dev repo, however, pnpm 10 keeps daemon deps under
+ * `packages/daemon/node_modules/`. `import("better-sqlite3")` from a
+ * top-level CLI script (bin/aitne.mjs, scripts/commands/*.mjs) returns
+ * ERR_MODULE_NOT_FOUND. This helper falls back to the daemon's own
+ * resolver in that case so the dev-time CLI behaves identically to the
+ * installed CLI.
+ *
+ * Returns the default-exported `Database` constructor.
+ */
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+export async function loadBetterSqlite3(projectRoot) {
+  // Standard path first.
+  try {
+    const mod = await import("better-sqlite3");
+    return mod.default ?? mod;
+  } catch (err) {
+    if (err?.code !== "ERR_MODULE_NOT_FOUND") throw err;
+  }
+
+  // Dev fallback — resolve via the daemon's own require.
+  const daemonPkgPath = path.join(projectRoot, "packages", "daemon", "package.json");
+  if (!fs.existsSync(daemonPkgPath)) {
+    const err = new Error(
+      "better-sqlite3 is not installed. Run `pnpm install` from the repo root, "
+      + "or reinstall the npm package.",
+    );
+    err.code = "ERR_MODULE_NOT_FOUND";
+    throw err;
+  }
+  const req = createRequire(pathToFileURL(daemonPkgPath));
+  // require() returns the constructor directly for better-sqlite3.
+  return req("better-sqlite3");
+}