@mean-weasel/lineage 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.10
+
+- Fix `lineage db info` so installed CLI checks use the same stable/dev runtime SQLite defaults as `lineage start`.
+
+## 0.1.9
+
+- Add runtime identity diagnostics in Settings so operators can see the active channel, version, Git SHA when available, SQLite path, and database counts.
+- Add `lineage db info` for CLI and agent checks before touching a local Lineage database.
+- Document the stable, preview, and dev channel data policy, keeping explicit database overrides available with `--db` and `LINEAGE_DB`.
+- Add browser coverage to ensure Settings keeps surfacing the active runtime and SQLite identity.
+
 ## 0.1.8
 
 - Add durable selection packet export so agents can hand selected Lineage assets to GrowthOps without scraping UI state or copying local paths.

package/README.md

@@ -4,19 +4,20 @@ Lineage is a local-first workspace for reviewing creative assets, branching vari
 
 ## Package Channels
 
-Lineage is packaged as `@mean-weasel/lineage`. Use `latest` for the stable dogfood or production install, and use `next` when you intentionally want the development or release-candidate channel:
+Lineage is packaged as `@mean-weasel/lineage`. Use `latest` for the stable dogfood or production install, and use `next` when you intentionally want the published preview candidate:
 
 ```bash
 npm install -g @mean-weasel/lineage@latest
 npm install -g @mean-weasel/lineage@next
 ```
 
-The stable and development channels are intended to coexist conceptually:
+The stable, preview, and dev channels are intended to coexist conceptually:
 
 - `latest` is the version you should trust for day-to-day dogfooding.
-- `next` is the version to test before promotion.
+- `next` is the published preview version to test before promotion.
+- `dev` is the local GitHub checkout or branch before publication.
 - `lineage` runs with stable runtime defaults.
-- `lineage-dev` runs with development runtime defaults.
+- `lineage-dev` runs with dev runtime defaults.
 
 The package includes both CLI bridge bins for help and version checks:
 
@@ -40,6 +41,30 @@ By default, `lineage start` listens on `lineage.localhost:5197` and stores SQLit
 lineage start --port 6123 --db ~/.lineage/lineage.sqlite
 ```
 
+## Runtime Channels and SQLite
+
+Lineage treats app code channels and local SQLite data as separate concerns:
+
+- `stable` is npm `latest` and is the daily-use channel.
+- `preview` is the published candidate channel, normally npm `next`.
+- `dev` is a GitHub checkout or local branch before publication.
+
+Each channel should use its own default runtime directory and SQLite database.
+Do not point preview or dev code at the stable database unless you are doing an
+intentional, explicit test. Prefer copying a stable snapshot forward when a
+realistic preview/dev dataset is needed. `--db` and `LINEAGE_DB` remain the
+escape hatches for intentionally choosing a database.
+
+Check the active runtime before making changes:
+
+```bash
+lineage db info --json
+lineage-dev db info --json
+```
+
+The app also shows channel, version, Git SHA when available, and SQLite path in
+Settings.
+
 ## Agent Claims
 
 Mutating agent writes use target-scoped claim tokens. Read-only inspection stays

package/dist/cli/lineage-dev.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve5 } from "node:path";
+import { dirname as dirname3, join as join7, resolve as resolve5 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -283,8 +283,8 @@ function isPackageRoot(path) {
   const packageJson = join3(path, "package.json");
   if (!existsSync3(packageJson)) return false;
   try {
-    const packageInfo = JSON.parse(readFileSync2(packageJson, "utf8"));
-    return packageInfo.name === "@mean-weasel/lineage";
+    const packageInfo2 = JSON.parse(readFileSync2(packageJson, "utf8"));
+    return packageInfo2.name === "@mean-weasel/lineage";
   } catch {
     return false;
   }
@@ -3593,6 +3593,74 @@ function getLineageSelectionPacket(project, options = {}) {
   };
 }
 
+// src/server/runtimeInfo.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createRequire as createRequire2 } from "node:module";
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+var require3 = createRequire2(import.meta.url);
+function packageInfo() {
+  try {
+    const info = JSON.parse(readFileSync3(join6(repoRoot, "package.json"), "utf8"));
+    return { name: info.name || "@mean-weasel/lineage", version: info.version || "0.0.0" };
+  } catch {
+    return { name: "@mean-weasel/lineage", version: "0.0.0" };
+  }
+}
+function normalizeRuntimeChannel(value) {
+  if (value === "stable" || value === "preview" || value === "dev") return value;
+  if (value === "production") return "stable";
+  if (value === "next") return "preview";
+  if (value === "development") return "dev";
+  return process.env.NODE_ENV === "production" ? "stable" : "dev";
+}
+function gitSha() {
+  const envSha = process.env.LINEAGE_GIT_SHA || process.env.GITHUB_SHA;
+  if (envSha) return envSha.slice(0, 40);
+  if (!existsSync6(join6(repoRoot, ".git"))) return void 0;
+  const result = spawnSync2("git", ["rev-parse", "--short=12", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() || void 0 : void 0;
+}
+function tableExists(database, table) {
+  return Boolean(database.prepare("select name from sqlite_master where type = 'table' and name = ?").get(table));
+}
+function tableCount(database, table) {
+  if (!tableExists(database, table)) return void 0;
+  const row = database.prepare(`select count(*) count from ${table}`).get();
+  return typeof row?.count === "number" ? row.count : void 0;
+}
+function getLineageRuntimeInfo(options = {}) {
+  const info = packageInfo();
+  const dbPath = options.dbPath || lineageDbPath();
+  const databaseInfo = { exists: existsSync6(dbPath), path: dbPath };
+  if (databaseInfo.exists) {
+    try {
+      const stat = statSync5(dbPath);
+      databaseInfo.modified_at = stat.mtime.toISOString();
+      databaseInfo.size_bytes = stat.size;
+      const { DatabaseSync } = require3("node:sqlite");
+      const database = new DatabaseSync(dbPath, { readOnly: true });
+      try {
+        databaseInfo.projects = tableCount(database, "projects");
+        databaseInfo.workspaces = tableCount(database, "lineage_workspaces");
+      } finally {
+        database.close();
+      }
+    } catch (error) {
+      databaseInfo.error = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return {
+    channel: normalizeRuntimeChannel(options.channel || process.env.LINEAGE_CHANNEL || process.env.LINEAGE_RELEASE_CHANNEL),
+    database: databaseInfo,
+    fetchedAt: nowIso(),
+    git_sha: gitSha(),
+    node_env: process.env.NODE_ENV,
+    package_name: info.name,
+    version: info.version
+  };
+}
+
 // src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
@@ -3603,17 +3671,17 @@ function packageRoot() {
 }
 function packageVersion() {
   try {
-    const packageInfo = JSON.parse(readFileSync3(join6(packageRoot(), "package.json"), "utf8"));
-    return packageInfo.version || "0.0.0";
+    const packageInfo2 = JSON.parse(readFileSync4(join7(packageRoot(), "package.json"), "utf8"));
+    return packageInfo2.version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function dataRoot(displayName) {
   if (process.env.LINEAGE_HOME) return process.env.LINEAGE_HOME;
-  if (platform() === "darwin") return join6(homedir(), "Library", "Application Support", displayName);
-  if (platform() === "win32") return join6(process.env.APPDATA || join6(homedir(), "AppData", "Roaming"), displayName);
-  return join6(process.env.XDG_DATA_HOME || join6(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
+  if (platform() === "darwin") return join7(homedir(), "Library", "Application Support", displayName);
+  if (platform() === "win32") return join7(process.env.APPDATA || join7(homedir(), "AppData", "Roaming"), displayName);
+  return join7(process.env.XDG_DATA_HOME || join7(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
 }
 function readOption(args, name) {
   const prefix = `${name}=`;
@@ -3637,20 +3705,22 @@ function readOptions(args, name) {
   return values;
 }
 function resolveStartOptions(config, args) {
-  const runtimeDir = dataRoot(config.displayName);
   const rawPort = readOption(args, "--port") || process.env.PORT || String(config.defaultPort);
   const port = Number(rawPort);
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
     throw new Error(`Invalid port: ${rawPort}`);
   }
   return {
-    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join6(runtimeDir, `${config.binName}.sqlite`),
+    dbPath: resolveCliDbPath(config, args),
     host: readOption(args, "--host") || process.env.HOST || config.defaultHost,
     json: args.includes("--json"),
     open: args.includes("--open"),
     port
   };
 }
+function resolveCliDbPath(config, args) {
+  return readOption(args, "--db") || process.env.LINEAGE_DB || join7(dataRoot(config.displayName), `${config.binName}.sqlite`);
+}
 function formatLineageHelp(config) {
   return `${config.binName} ${packageVersion()}
 
@@ -3674,6 +3744,7 @@ Usage:
   ${config.binName} tasks cancel --task <task-id> [--confirm-write] [--override] [--project <project>] [--db <path>] [--json]
   ${config.binName} tasks override --task <task-id> --reason <text> [--instructions <text>] [--project <project>] [--db <path>] [--json]
   ${config.binName} tasks instructions --task <task-id> --instructions <text> [--project <project>] [--db <path>] [--json]
+  ${config.binName} db info [--db <path>] [--json]
   ${config.binName} agent claim --project <project> --scope <scope> --target <target-id> --agent-name <name> [--channel <channel>] [--ttl 20m] [--json]
   ${config.binName} agent graph --root <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} agent status [--project <project>] [--json]
@@ -3958,6 +4029,34 @@ function printDataResult(command, result, json) {
   }
   console.log(String(result));
 }
+function runLineageDbCommand(config, command, args) {
+  const dbPath = resolveCliDbPath(config, args);
+  process.env.LINEAGE_DB = dbPath;
+  if (command === "info") return getLineageRuntimeInfo({ channel: config.channel, dbPath });
+  throw new Error(`Unknown db command: ${command}`);
+}
+function printDbResult(command, result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (command === "info" && result && typeof result === "object" && "database" in result) {
+    const runtime = result;
+    console.log(`Channel: ${runtime.channel}`);
+    console.log(`Version: ${runtime.version}`);
+    if (runtime.git_sha) console.log(`Git: ${runtime.git_sha}`);
+    if (runtime.node_env) console.log(`Node env: ${runtime.node_env}`);
+    console.log(`SQLite: ${runtime.database.path}`);
+    console.log(`Exists: ${runtime.database.exists ? "yes" : "no"}`);
+    if (runtime.database.size_bytes !== void 0) console.log(`Size: ${runtime.database.size_bytes} bytes`);
+    if (runtime.database.modified_at) console.log(`Modified: ${runtime.database.modified_at}`);
+    if (runtime.database.projects !== void 0) console.log(`Projects: ${runtime.database.projects}`);
+    if (runtime.database.workspaces !== void 0) console.log(`Workspaces: ${runtime.database.workspaces}`);
+    if (runtime.database.error) console.log(`Warning: ${runtime.database.error}`);
+    return;
+  }
+  console.log(String(result));
+}
 function runLineageAgentCommand(command, args) {
   const dbPath = readOption(args, "--db");
   if (dbPath) process.env.LINEAGE_DB = dbPath;
@@ -4084,8 +4183,8 @@ function start(config, args) {
     else console.error(`${config.binName}: ${message}`);
     process.exit(1);
   }
-  const serverPath = join6(packageRoot(), "dist", "server.js");
-  if (!existsSync6(serverPath)) {
+  const serverPath = join7(packageRoot(), "dist", "server.js");
+  if (!existsSync7(serverPath)) {
     const message = `Missing bundled server at ${serverPath}. Run npm run build before using ${config.binName} start from a source checkout.`;
     if (options.json) console.error(JSON.stringify({ ok: false, error: message }, null, 2));
     else console.error(`${config.binName}: ${message}`);
@@ -4154,6 +4253,20 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     }
     process.exit(0);
   }
+  if (command === "db") {
+    const commandArgs = normalizedArgs.slice(2);
+    const dbCommand = normalizedArgs[1] || "";
+    const json2 = commandArgs.includes("--json");
+    try {
+      printDbResult(dbCommand, runLineageDbCommand(config, dbCommand, commandArgs), json2);
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      if (json2) console.error(JSON.stringify({ ok: false, command: `db ${dbCommand}`, error: message2 }, null, 2));
+      else console.error(`${config.binName}: ${message2}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
   if (command === "agent") {
     const commandArgs = normalizedArgs.slice(2);
     const agentCommand = normalizedArgs[1] || "";
@@ -4180,5 +4293,5 @@ function runLineageCli(config, args = process.argv.slice(2)) {
 }
 
 // src/cli/lineage-dev.ts
-runLineageCli({ binName: "lineage-dev", channel: "development", defaultHost: "lineage-dev.localhost", defaultPort: 5198, displayName: "Lineage Dev" });
+runLineageCli({ binName: "lineage-dev", channel: "dev", defaultHost: "lineage-dev.localhost", defaultPort: 5198, displayName: "Lineage Dev" });
 //# sourceMappingURL=lineage-dev.js.map