@mean-weasel/lineage 0.1.18 → 0.1.20

package/dist/runtime-build.json

@@ -1,9 +1,9 @@
 {
-  "build_fingerprint": "06b247a5facc91f5229fcc17b7ae8bb22a2d3e663f4fd1520bb50152254669fe",
+  "build_fingerprint": "de1fd2e2ce5b6d3ac17b832c06fe62e8780bf94bdc5d5d07221dde3392452510",
   "package_name": "@mean-weasel/lineage",
-  "package_version": "0.1.18",
+  "package_version": "0.1.20",
   "schema_version": "lineage.runtime_build.v1",
   "source_dirty": false,
-  "source_fingerprint": "f57dfbc56b806bf349bab7a5a4431c014e76cdb04321e610178a8b85707679b0",
-  "source_git_sha": "7b7a0ba3166359522a78bf918bf3e88e471bf933"
+  "source_fingerprint": "c7f120476e5880d644e3da2ac1b46ff26964935e9dcca490a79b461d4726cae5",
+  "source_git_sha": "9b3e36ba2e2752b4f9dd414ffdade8dd946b69b4"
 }

package/dist/server.js

@@ -282,7 +282,6 @@ function createS3StorageAdapter(deps) {
 }
 
 // src/server/assetLineageDb.ts
-import { createRequire as createRequire2 } from "node:module";
 import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
 import { join as join5 } from "node:path";
 
@@ -293,7 +292,6 @@ import { dirname as dirname3, join as join4, resolve as resolve3 } from "node:pa
 
 // src/server/lineageProfiles.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { createRequire } from "node:module";
 import {
   chmodSync,
   closeSync,
@@ -319,8 +317,26 @@ import { dirname as dirname2, isAbsolute, join as join3, relative as relative2,
 var lineageProfileSchemaVersion = "lineage.profile.v1";
 var lineageProfileDoctorSchemaVersion = "lineage.profile_doctor.v1";
 
-// src/server/lineageProfiles.ts
+// src/server/nodeSqlite.ts
+import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
+var sqliteExperimentalWarning = "SQLite is an experimental feature and might change at any time";
+function loadNodeSqlite() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = warning instanceof Error ? warning.message : warning;
+    const type = typeof args[0] === "string" ? args[0] : warning instanceof Error ? warning.name : void 0;
+    if (message === sqliteExperimentalWarning && type === "ExperimentalWarning") return;
+    return Reflect.apply(emitWarning, process, [warning, ...args]);
+  });
+  try {
+    return require2("node:sqlite");
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+}
+
+// src/server/lineageProfiles.ts
 var profileIdPattern = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 function lineageDataRoot() {
   if (process.env.LINEAGE_HOME) return resolve2(process.env.LINEAGE_HOME);
@@ -499,7 +515,7 @@ function inspectDatabase(profile) {
   };
   if (!result.exists) return result;
   try {
-    const { DatabaseSync } = require2("node:sqlite");
+    const { DatabaseSync } = loadNodeSqlite();
     const database = new DatabaseSync(profile.database_path, { readOnly: true });
     try {
       if (tableExists(database, "lineage_profile_identity")) {
@@ -857,7 +873,6 @@ function assertSelectedProfileDatabaseIdentity(database) {
 }
 
 // src/server/assetLineageDb.ts
-var require3 = createRequire2(import.meta.url);
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -871,7 +886,7 @@ function lineageDb() {
     throw new Error(`Refusing writable open of missing profile database ${lineageDbPath()}; bind an existing database or create a non-production clone first`);
   }
   if (!readOnly) mkdirSync4(join5(lineageDbPath(), ".."), { recursive: true });
-  const { DatabaseSync } = require3("node:sqlite");
+  const { DatabaseSync } = loadNodeSqlite();
   const database = readOnly ? new DatabaseSync(lineageDbPath(), { readOnly: true }) : new DatabaseSync(lineageDbPath());
   if (process.env.LINEAGE_PROFILE) assertSelectedProfileDatabaseIdentity(database);
   database.exec("PRAGMA foreign_keys = ON");
@@ -4504,32 +4519,38 @@ function updateAssetReview(project, fields) {
 
 // src/server/lineageRuntimeCommand.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { join as join8 } from "node:path";
-var require4 = createRequire3(import.meta.url);
-function lineagePublicPackageCommand() {
-  if (process.env.LINEAGE_CHANNEL === "dev") {
+var require3 = createRequire2(import.meta.url);
+function lineageCliLauncher(channel = process.env.LINEAGE_CHANNEL) {
+  if (channel === "dev") {
     const sourceCli = join8(packageRoot, "src", "cli", "lineage-dev.ts");
     const builtCli = join8(packageRoot, "dist", "cli", "lineage-dev.js");
-    return existsSync7(sourceCli) ? `${shellQuote(process.execPath)} --import ${shellQuote(require4.resolve("tsx"))} ${shellQuote(sourceCli)}` : `${shellQuote(process.execPath)} ${shellQuote(builtCli)}`;
+    return existsSync7(sourceCli) ? `${shellQuote(process.execPath)} --import ${shellQuote(require3.resolve("tsx"))} ${shellQuote(sourceCli)}` : `${shellQuote(process.execPath)} ${shellQuote(builtCli)}`;
   }
-  if (process.env.LINEAGE_CHANNEL === "preview") return "LINEAGE_CHANNEL=preview npx --package @mean-weasel/lineage@next lineage-dev";
-  return "npx @mean-weasel/lineage";
+  if (channel === "preview") return "lineage-preview";
+  if (channel === "stable") return "lineage-stable";
+  throw new Error("LINEAGE_CHANNEL must be stable, preview, or dev before generating a Lineage command");
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
-function lineageRuntimeSelector() {
+function lineageRuntimeSelector(databasePath) {
   const manifest = process.env.LINEAGE_PROFILE_MANIFEST?.trim();
-  return manifest ? `--profile ${shellQuote(manifest)}` : `--db ${shellQuote(lineageDbPath())}`;
+  const database = databasePath || process.env.LINEAGE_DB || join8(packageRoot, ".lineage", "asset-lineage.sqlite");
+  return manifest ? `--profile ${shellQuote(manifest)}` : `--db ${shellQuote(database)}`;
+}
+function lineageCliCommand(command) {
+  const normalized = command.trim().replace(/\s+--json$/, "");
+  return `${lineageCliLauncher()} ${normalized} ${lineageRuntimeSelector()} --json`;
 }
 
 // src/server/assetLineageHandoff.ts
 function lineageCommand(command, project, rootAssetId) {
-  return `${lineagePublicPackageCommand()} ${command} --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} ${lineageRuntimeSelector()} --json`;
+  return lineageCliCommand(`${command} --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)}`);
 }
 function linkChildCommand(project, rootAssetId) {
-  return `${lineagePublicPackageCommand()} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --summary "<one-or-two-words>" --confirm-write ${lineageRuntimeSelector()} --json`;
+  return lineageCliCommand(`link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --summary "<one-or-two-words>" --confirm-write`);
 }
 function rerollImportGuidance(rootAssetId, targetAssetId) {
   return `Use lineage reroll plan --root ${rootAssetId} --target ${targetAssetId} and lineage reroll import instead.`;
@@ -4571,7 +4592,7 @@ function getLineageBrief(project, rootAssetId) {
     },
     handoff: {
       next_command: lineageCommand("next", project, next.root_asset_id),
-      inspect_command: asset ? `${lineagePublicPackageCommand()} inspect --project ${shellQuote(project)} --asset-id ${shellQuote(asset.asset_id)} ${lineageRuntimeSelector()} --json` : void 0,
+      inspect_command: asset ? lineageCliCommand(`inspect --project ${shellQuote(project)} --asset-id ${shellQuote(asset.asset_id)}`) : void 0,
       link_child_command: asset ? linkChildCommand(project, next.root_asset_id) : void 0
     },
     fetchedAt: nowIso()
@@ -5379,13 +5400,13 @@ function laneFor(channel, localAssets2, catalogAssets, limit) {
   };
 }
 function handoff(project) {
-  const prefix = `npx @mean-weasel/lineage`;
+  const quotedProject = shellQuote(project);
   return {
-    backupTemplate: `${prefix} local backup --project ${project} --asset-id <local-id> --dry-run --json`,
-    lineageNextTemplate: `${prefix} lineage next --project ${project} --root <root-id> --json`,
-    localListCommand: `${prefix} local list --project ${project} --json`,
-    queueCommand: `${prefix} review queue --project ${project} --json`,
-    scheduleTemplate: `${prefix} placement mark-scheduled --project ${project} --asset-id <asset-id> --channel <channel> --scheduled-at <iso> --dry-run --json`
+    backupTemplate: lineageCliCommand(`local backup --project ${quotedProject} --asset-id <local-id> --dry-run`),
+    lineageNextTemplate: lineageCliCommand(`lineage next --project ${quotedProject} --root <root-id>`),
+    localListCommand: lineageCliCommand(`local list --project ${quotedProject}`),
+    queueCommand: lineageCliCommand(`review queue --project ${quotedProject}`),
+    scheduleTemplate: lineageCliCommand(`placement mark-scheduled --project ${quotedProject} --asset-id <asset-id> --channel <channel> --scheduled-at <iso> --dry-run`)
   };
 }
 function getReviewQueue(project = defaultProject, options = {}) {
@@ -6197,19 +6218,19 @@ function readinessForPost(post) {
   return post.assets.length === 0 ? "needs_asset" : "draft_ready";
 }
 function contentPostHandoff(project, post) {
-  const prefix = "npx lineage content";
-  const postId = post?.id || "<post-id>";
-  const batchId = post?.batch_id;
+  const quotedProject = shellQuote(project);
+  const postId = post ? shellQuote(post.id) : "<post-id>";
+  const batchId = post?.batch_id ? shellQuote(post.batch_id) : void 0;
   return {
     agentPrompt: post ? `Continue content iterations for ${post.title} (${post.id}) on ${post.channel}. Inspect the target, generate or choose assets, attach approved candidates, then move the post through review before scheduling.` : "Inspect or set a content target before generating content or asset variations.",
-    attachAssetTemplate: `${prefix} post attach-asset --project ${project} --post-id ${postId} --asset-id <asset-id> --role primary --confirm-write --json`,
-    clearTargetCommand: `${prefix} target clear --project ${project} --confirm-write --json`,
-    ...batchId ? { inspectBatchCommand: `${prefix} batch inspect --project ${project} --batch-id ${batchId} --json` } : {},
-    inspectTargetCommand: `${prefix} target inspect --project ${project} --json`,
-    markPostedTemplate: `${prefix} post phase --project ${project} --post-id ${postId} --phase posted --posted-at <iso> --url <url> --confirm-write --json`,
-    moveToReviewCommand: `${prefix} post phase --project ${project} --post-id ${postId} --phase review --confirm-write --json`,
-    scheduleTemplate: `${prefix} post phase --project ${project} --post-id ${postId} --phase scheduled --scheduled-at <iso> --confirm-write --json`,
-    setTargetTemplate: `${prefix} target set --project ${project} --post-id ${postId} --notes <notes> --confirm-write --json`
+    attachAssetTemplate: lineageCliCommand(`content post attach-asset --project ${quotedProject} --post-id ${postId} --asset-id <asset-id> --role primary --confirm-write`),
+    clearTargetCommand: lineageCliCommand(`content target clear --project ${quotedProject} --confirm-write`),
+    ...batchId ? { inspectBatchCommand: lineageCliCommand(`content batch inspect --project ${quotedProject} --batch-id ${batchId}`) } : {},
+    inspectTargetCommand: lineageCliCommand(`content target inspect --project ${quotedProject}`),
+    markPostedTemplate: lineageCliCommand(`content post phase --project ${quotedProject} --post-id ${postId} --phase posted --posted-at <iso> --url <url> --confirm-write`),
+    moveToReviewCommand: lineageCliCommand(`content post phase --project ${quotedProject} --post-id ${postId} --phase review --confirm-write`),
+    scheduleTemplate: lineageCliCommand(`content post phase --project ${quotedProject} --post-id ${postId} --phase scheduled --scheduled-at <iso> --confirm-write`),
+    setTargetTemplate: lineageCliCommand(`content target set --project ${quotedProject} --post-id ${postId} --notes <notes> --confirm-write`)
   };
 }
 
@@ -6309,12 +6330,13 @@ function phaseCounts(posts) {
   return Object.fromEntries([...phases].map((phase) => [phase, posts.filter((post) => post.phase === phase).length]));
 }
 function handoff2(project, batchId) {
-  const prefix = `npx lineage content`;
+  const quotedProject = shellQuote(project);
+  const quotedBatch = shellQuote(batchId);
   return {
-    inspectCommand: `${prefix} batch inspect --project ${project} --batch-id ${batchId} --json`,
-    createPostTemplate: `${prefix} post create --project ${project} --batch-id ${batchId} --post-id <post-id> --channel <channel> --title <title> --confirm-write --json`,
-    attachAssetTemplate: `${prefix} post attach-asset --project ${project} --post-id <post-id> --asset-id <asset-id> --role primary --confirm-write --json`,
-    phaseTemplate: `${prefix} post phase --project ${project} --post-id <post-id> --phase scheduled --scheduled-at <iso> --confirm-write --json`
+    inspectCommand: lineageCliCommand(`content batch inspect --project ${quotedProject} --batch-id ${quotedBatch}`),
+    createPostTemplate: lineageCliCommand(`content post create --project ${quotedProject} --batch-id ${quotedBatch} --post-id <post-id> --channel <channel> --title <title> --confirm-write`),
+    attachAssetTemplate: lineageCliCommand(`content post attach-asset --project ${quotedProject} --post-id <post-id> --asset-id <asset-id> --role primary --confirm-write`),
+    phaseTemplate: lineageCliCommand(`content post phase --project ${quotedProject} --post-id <post-id> --phase scheduled --scheduled-at <iso> --confirm-write`)
   };
 }
 function listContentBatches(project) {
@@ -6991,10 +7013,10 @@ function backupCueForPost(project, post, sources) {
     approved_local: approvedLocal,
     label,
     local_and_s3: localAndS3,
-    local_backup_command: firstLocalOnly ? `npx lineage local backup --project ${project} --asset-id ${firstLocalOnly} --dry-run --json` : void 0,
+    local_backup_command: firstLocalOnly ? lineageCliCommand(`local backup --project ${shellQuote(project)} --asset-id ${shellQuote(firstLocalOnly)} --dry-run`) : void 0,
     local_only: localOnly,
-    local_queue_command: firstLocalOnly ? `npx lineage local queue --project ${project} --json` : void 0,
-    local_review_command: firstLocalOnly ? `npx lineage local review --project ${project} --asset-id ${firstLocalOnly} --state approved --dry-run --json` : void 0,
+    local_queue_command: firstLocalOnly ? lineageCliCommand(`local queue --project ${shellQuote(project)}`) : void 0,
+    local_review_command: firstLocalOnly ? lineageCliCommand(`local review --project ${shellQuote(project)} --asset-id ${shellQuote(firstLocalOnly)} --state approved --dry-run`) : void 0,
     needs_review: needsReview,
     s3_backed: s3Backed,
     unresolved
@@ -7040,13 +7062,13 @@ function getContentOpsQueue(project) {
   const nextAction = firstLaneItem(queueLanes, actionableLaneOrder);
   const storage = items.reduce((total, item) => addStorage(total, item.asset_storage), emptyStorage());
   const laneTotals = Object.fromEntries(queueLanes.map((lane) => [lane.id, lane.total]));
-  const contentPrefix = `npx lineage content`;
+  const quotedProject = shellQuote(project);
   return {
     fetchedAt: nowIso(),
     handoff: {
-      inspectQueueCommand: `${contentPrefix} queue inspect --project ${project} --json`,
-      inspectTargetCommand: `${contentPrefix} target inspect --project ${project} --json`,
-      listPostsCommand: `${contentPrefix} post list --project ${project} --json`
+      inspectQueueCommand: lineageCliCommand(`content queue inspect --project ${quotedProject}`),
+      inspectTargetCommand: lineageCliCommand(`content target inspect --project ${quotedProject}`),
+      listPostsCommand: lineageCliCommand(`content post list --project ${quotedProject}`)
     },
     lanes: queueLanes,
     next_action: nextAction?.item || null,
@@ -7377,7 +7399,7 @@ function buildHandoff(project, id, prompt, count, perBaseCount, next, inputs) {
   if (!parent) throw new GenerationReceiptError("Missing lineage next base");
   const parents = parentMappings(next, perBaseCount);
   const outputManifest = createGenerationOutputManifestDraft({ id, expected_output_count: count, inputs });
-  const importCommand = `${lineagePublicPackageCommand()} generate image import --project ${quote(project)} --job-id ${quote(id)} --manifest ${quote(".asset-scratch/generation-output-manifest.json")} --confirm-write ${lineageRuntimeSelector()} --json`;
+  const importCommand = lineageCliCommand(`generate image import --project ${quote(project)} --job-id ${quote(id)} --manifest ${quote(".asset-scratch/generation-output-manifest.json")} --confirm-write`);
   return {
     schema_version: "lineage.generation_handoff.v2",
     provider,
@@ -7414,7 +7436,7 @@ function buildHandoff(project, id, prompt, count, perBaseCount, next, inputs) {
   };
 }
 function buildRerollHandoff(project, id, prompt, rootAssetId, target, request) {
-  const importCommand = `${lineagePublicPackageCommand()} reroll import --project ${quote(project)} --job-id ${quote(id)} --file <.asset-scratch-file> --confirm-write ${lineageRuntimeSelector()} --json`;
+  const importCommand = lineageCliCommand(`reroll import --project ${quote(project)} --job-id ${quote(id)} --file <.asset-scratch-file> --confirm-write`);
   return {
     schema_version: "lineage.generation_handoff.v1",
     provider,
@@ -8864,7 +8886,6 @@ function registerLineageWorkspaceRoutes(app2, projectFrom2, asyncRoute2) {
 // src/server/runtimeInfo.ts
 import { createHash as createHash6 } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { createRequire as createRequire4 } from "node:module";
 import { existsSync as existsSync11, lstatSync as lstatSync3, readFileSync as readFileSync7, readdirSync as readdirSync4, readlinkSync, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
 import { dirname as dirname6, isAbsolute as isAbsolute2, join as join12, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -8874,7 +8895,6 @@ var lineageRuntimeBuildSchemaVersion = "lineage.runtime_build.v1";
 var lineageRuntimeInstallSchemaVersion = "lineage.runtime_install.v1";
 
 // src/server/runtimeInfo.ts
-var require5 = createRequire4(import.meta.url);
 var processStartedAt = (/* @__PURE__ */ new Date()).toISOString();
 function isLineagePackageRoot(root) {
   try {
@@ -9138,7 +9158,7 @@ function getLineageRuntimeInfo(options = {}) {
       const stat = statSync5(dbPath);
       databaseInfo.modified_at = stat.mtime.toISOString();
       databaseInfo.size_bytes = stat.size;
-      const { DatabaseSync } = require5("node:sqlite");
+      const { DatabaseSync } = loadNodeSqlite();
       const database = new DatabaseSync(dbPath, { readOnly: true });
       try {
         databaseInfo.projects = tableCount(database, "projects");
@@ -9164,6 +9184,10 @@ function getLineageRuntimeInfo(options = {}) {
   return {
     asset_root: repoRoot,
     channel,
+    cli: {
+      launcher: lineageCliLauncher(channel),
+      runtime_selector: lineageRuntimeSelector(dbPath)
+    },
     code,
     database: databaseInfo,
     fetchedAt: nowIso(),