@hasna/instructions 0.6.1 → 0.7.0

package/dist/chunks/legacy-store-migration-z2m5yzyk.js

@@ -0,0 +1,322 @@
+// @bun
+import"./index-bsan4c16.js";
+
+// src/lib/legacy-store-migration.ts
+import { Database } from "bun:sqlite";
+import { chmodSync, constants, copyFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { createHash } from "crypto";
+import { dirname, join, resolve } from "path";
+import { homedir } from "os";
+
+class LegacyStoreMigrationError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "LegacyStoreMigrationError";
+    this.code = code;
+  }
+}
+function emptyCounts() {
+  return { configs: 0, snapshots: 0, profiles: 0, profileConfigs: 0, machines: 0 };
+}
+function legacyInstructionsStorePaths(home = process.env.HOME || homedir()) {
+  return {
+    sourcePath: join(home, ".hasna", "configs", "configs.db"),
+    destinationPath: join(home, ".hasna", "instructions", "instructions.db")
+  };
+}
+function tableExists(db, table) {
+  return db.query("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?").get(table)?.present === 1;
+}
+function columns(db, table) {
+  if (!tableExists(db, table))
+    return new Set;
+  return new Set(db.query(`PRAGMA table_info(${table})`).all().map((row) => row.name));
+}
+function rows(db, table) {
+  if (!tableExists(db, table))
+    return [];
+  return db.query(`SELECT * FROM ${table} ORDER BY rowid`).all();
+}
+function value(row, name, fallback) {
+  return Object.prototype.hasOwnProperty.call(row, name) && row[name] !== undefined ? row[name] : fallback;
+}
+function normalizeJson(valueToNormalize, fallback) {
+  if (typeof valueToNormalize !== "string")
+    return fallback;
+  try {
+    JSON.parse(valueToNormalize);
+    return valueToNormalize;
+  } catch {
+    return fallback;
+  }
+}
+function compatibleConfig(row) {
+  return {
+    id: value(row, "id", ""),
+    name: value(row, "name", ""),
+    slug: value(row, "slug", ""),
+    kind: value(row, "kind", "file"),
+    category: value(row, "category", "rules"),
+    agent: value(row, "agent", "global"),
+    target_path: value(row, "target_path", null),
+    outputs: normalizeJson(value(row, "outputs", "[]"), "[]"),
+    format: value(row, "format", "text"),
+    content: value(row, "content", ""),
+    description: value(row, "description", null),
+    tags: normalizeJson(value(row, "tags", "[]"), "[]"),
+    is_template: value(row, "is_template", 0),
+    version: value(row, "version", 1),
+    created_at: value(row, "created_at", "1970-01-01T00:00:00.000Z"),
+    updated_at: value(row, "updated_at", value(row, "created_at", "1970-01-01T00:00:00.000Z")),
+    synced_at: value(row, "synced_at", null)
+  };
+}
+function compatibleProfile(row) {
+  return {
+    id: value(row, "id", ""),
+    name: value(row, "name", ""),
+    slug: value(row, "slug", ""),
+    description: value(row, "description", null),
+    selectors: normalizeJson(value(row, "selectors", "{}"), "{}"),
+    variables: normalizeJson(value(row, "variables", "{}"), "{}"),
+    created_at: value(row, "created_at", "1970-01-01T00:00:00.000Z"),
+    updated_at: value(row, "updated_at", value(row, "created_at", "1970-01-01T00:00:00.000Z"))
+  };
+}
+function compatibleMachine(row) {
+  return {
+    id: value(row, "id", ""),
+    hostname: value(row, "hostname", ""),
+    os: value(row, "os", null),
+    arch: value(row, "arch", null),
+    last_applied_at: value(row, "last_applied_at", null),
+    created_at: value(row, "created_at", "1970-01-01T00:00:00.000Z")
+  };
+}
+function stableSnapshotId(config) {
+  const digest = createHash("sha256").update(String(config.id)).update("\x00").update(String(config.version)).update("\x00").update(String(config.content)).digest("hex").slice(0, 32);
+  return `legacy-current-${digest}`;
+}
+function countDestinationRows(db) {
+  return ["configs", "config_snapshots", "profiles", "profile_configs", "machines"].reduce((total, table) => {
+    if (!tableExists(db, table))
+      return total;
+    return total + (db.query(`SELECT COUNT(*) AS count FROM ${table}`).get()?.count ?? 0);
+  }, 0);
+}
+function requireCurrentSchema(db) {
+  const required = {
+    configs: ["id", "slug", "kind", "outputs", "content", "version"],
+    config_snapshots: ["id", "config_id", "content", "version"],
+    profiles: ["id", "slug", "selectors", "variables"],
+    profile_configs: ["profile_id", "config_id", "binding"],
+    machines: ["id", "hostname", "arch"]
+  };
+  for (const [table, names] of Object.entries(required)) {
+    const actual = columns(db, table);
+    if (names.some((name) => !actual.has(name))) {
+      throw new LegacyStoreMigrationError("DESTINATION_SCHEMA_INCOMPATIBLE", `instructions legacy migration: destination is not a current Instructions SQLite database (incompatible ${table} table)`);
+    }
+  }
+}
+function sameConfig(a, b) {
+  const keys = ["id", "name", "slug", "kind", "category", "agent", "target_path", "outputs", "format", "content", "description", "tags", "is_template", "version", "created_at", "updated_at", "synced_at"];
+  return keys.every((key) => String(a[key] ?? "") === String(b[key] ?? ""));
+}
+function buildPlan(source, destination, mergePolicy) {
+  const sourceCounts = emptyCounts();
+  const migrated = emptyCounts();
+  const skipped = emptyCounts();
+  const planned = [];
+  let conflicts = 0;
+  let snapshotsCreated = 0;
+  const sourceConfigs = rows(source, "configs").map(compatibleConfig);
+  const sourceSnapshots = rows(source, "config_snapshots");
+  const sourceProfiles = rows(source, "profiles").map(compatibleProfile);
+  const sourceProfileConfigs = rows(source, "profile_configs");
+  const sourceMachines = rows(source, "machines").map(compatibleMachine);
+  sourceCounts.configs = sourceConfigs.length;
+  sourceCounts.snapshots = sourceSnapshots.length;
+  sourceCounts.profiles = sourceProfiles.length;
+  sourceCounts.profileConfigs = sourceProfileConfigs.length;
+  sourceCounts.machines = sourceMachines.length;
+  const acceptedConfigIds = new Set;
+  for (const config of sourceConfigs) {
+    const id = String(config.id);
+    const existing = destination.query("SELECT * FROM configs WHERE id = ? OR slug = ? LIMIT 1").get(id, String(config.slug));
+    if (existing) {
+      skipped.configs++;
+      if (!sameConfig(existing, config))
+        conflicts++;
+      if (mergePolicy === "preserve-destination" && String(existing.id) === id && sameConfig(existing, config)) {
+        acceptedConfigIds.add(id);
+      }
+      continue;
+    }
+    acceptedConfigIds.add(id);
+    planned.push({ table: "configs", values: config });
+    migrated.configs++;
+  }
+  const snapshotIdentity = new Set;
+  for (const snapshot of sourceSnapshots) {
+    const configId = String(value(snapshot, "config_id", ""));
+    if (!acceptedConfigIds.has(configId)) {
+      skipped.snapshots++;
+      continue;
+    }
+    const normalized = {
+      id: value(snapshot, "id", ""),
+      config_id: configId,
+      content: value(snapshot, "content", ""),
+      version: value(snapshot, "version", 1),
+      created_at: value(snapshot, "created_at", "1970-01-01T00:00:00.000Z")
+    };
+    const identity = `${configId}\x00${normalized.version}\x00${normalized.content}`;
+    snapshotIdentity.add(identity);
+    const existing = destination.query("SELECT id FROM config_snapshots WHERE id = ?").get(String(normalized.id));
+    if (existing)
+      skipped.snapshots++;
+    else {
+      planned.push({ table: "snapshots", values: normalized });
+      migrated.snapshots++;
+    }
+  }
+  for (const config of sourceConfigs) {
+    const configId = String(config.id);
+    if (!acceptedConfigIds.has(configId))
+      continue;
+    const identity = `${configId}\x00${config.version}\x00${config.content}`;
+    const destinationHas = destination.query("SELECT 1 AS present FROM config_snapshots WHERE config_id = ? AND version = ? AND content = ? LIMIT 1").get(configId, Number(config.version), String(config.content));
+    if (!snapshotIdentity.has(identity) && !destinationHas) {
+      planned.push({ table: "snapshots", values: {
+        id: stableSnapshotId(config),
+        config_id: configId,
+        content: config.content,
+        version: config.version,
+        created_at: config.updated_at
+      } });
+      migrated.snapshots++;
+      snapshotsCreated++;
+    }
+  }
+  const acceptedProfileIds = new Set;
+  for (const profile of sourceProfiles) {
+    const existing = destination.query("SELECT id FROM profiles WHERE id = ? OR slug = ? LIMIT 1").get(String(profile.id), String(profile.slug));
+    if (existing) {
+      skipped.profiles++;
+      if (String(existing.id) !== String(profile.id))
+        conflicts++;
+    } else {
+      acceptedProfileIds.add(String(profile.id));
+      planned.push({ table: "profiles", values: profile });
+      migrated.profiles++;
+    }
+  }
+  for (const link of sourceProfileConfigs) {
+    const profileId = String(value(link, "profile_id", ""));
+    const configId = String(value(link, "config_id", ""));
+    if (!acceptedProfileIds.has(profileId) || !acceptedConfigIds.has(configId)) {
+      skipped.profileConfigs++;
+      continue;
+    }
+    planned.push({ table: "profileConfigs", values: {
+      profile_id: profileId,
+      config_id: configId,
+      sort_order: value(link, "sort_order", 0),
+      binding: normalizeJson(value(link, "binding", '{"schema":"hasna.instructions.profile-config-binding/v1","activation":{"mode":"always"},"required":true,"fallback":"fail"}'), "{}")
+    } });
+    migrated.profileConfigs++;
+  }
+  for (const machine of sourceMachines) {
+    const existing = destination.query("SELECT id FROM machines WHERE id = ? OR hostname = ? LIMIT 1").get(String(machine.id), String(machine.hostname));
+    if (existing) {
+      skipped.machines++;
+      if (String(existing.id) !== String(machine.id))
+        conflicts++;
+    } else {
+      planned.push({ table: "machines", values: machine });
+      migrated.machines++;
+    }
+  }
+  return { source: sourceCounts, migrated, skipped, conflicts, snapshotsCreated, rows: planned };
+}
+function insertRow(db, row) {
+  const table = row.table === "snapshots" ? "config_snapshots" : row.table === "profileConfigs" ? "profile_configs" : row.table;
+  const names = Object.keys(row.values);
+  const placeholders = names.map(() => "?").join(", ");
+  db.run(`INSERT INTO ${table} (${names.join(", ")}) VALUES (${placeholders})`, names.map((name) => row.values[name]));
+}
+function migrateLegacyInstructionsStore(options) {
+  if (!options.operatorConfirmed) {
+    throw new LegacyStoreMigrationError("LOCAL_OPERATOR_CONFIRMATION_REQUIRED", "instructions legacy migration requires explicit local operator confirmation");
+  }
+  const defaults = legacyInstructionsStorePaths();
+  const sourcePath = resolve(options.sourcePath ?? defaults.sourcePath);
+  const destinationPath = resolve(options.destinationPath ?? defaults.destinationPath);
+  const dryRun = options.dryRun ?? true;
+  if (sourcePath === destinationPath) {
+    throw new LegacyStoreMigrationError("SOURCE_DESTINATION_SAME", "instructions legacy migration source and destination must differ");
+  }
+  if (!existsSync(sourcePath) || !statSync(sourcePath).isFile()) {
+    throw new LegacyStoreMigrationError("SOURCE_NOT_FOUND", "instructions legacy migration source database was not found");
+  }
+  if (!existsSync(destinationPath) || !statSync(destinationPath).isFile()) {
+    throw new LegacyStoreMigrationError("DESTINATION_NOT_FOUND", "instructions legacy migration destination must be an initialized current Instructions SQLite database");
+  }
+  const source = new Database(sourcePath, { readonly: true, strict: true });
+  const destination = new Database(destinationPath, { strict: true });
+  let backupPath = null;
+  try {
+    source.run("PRAGMA query_only = ON");
+    destination.run("PRAGMA foreign_keys = ON");
+    requireCurrentSchema(destination);
+    const destinationRows = countDestinationRows(destination);
+    if (destinationRows > 0 && options.mergePolicy === undefined) {
+      throw new LegacyStoreMigrationError("DESTINATION_NOT_EMPTY", "instructions legacy migration refuses a non-empty destination without an explicit merge policy");
+    }
+    const plan = buildPlan(source, destination, options.mergePolicy);
+    if (!dryRun) {
+      backupPath = resolve(options.backupPath ?? `${destinationPath}.before-legacy-migration.bak`);
+      if (backupPath === sourcePath || backupPath === destinationPath) {
+        throw new LegacyStoreMigrationError("INVALID_BACKUP_PATH", "instructions legacy migration backup path must be separate");
+      }
+      if (existsSync(backupPath)) {
+        throw new LegacyStoreMigrationError("BACKUP_ALREADY_EXISTS", "instructions legacy migration refuses to overwrite an existing destination backup");
+      }
+      mkdirSync(dirname(backupPath), { recursive: true, mode: 448 });
+      destination.run("PRAGMA wal_checkpoint(FULL)");
+      copyFileSync(destinationPath, backupPath, constants.COPYFILE_EXCL);
+      chmodSync(backupPath, 384);
+      const apply = destination.transaction(() => {
+        for (const row of plan.rows)
+          insertRow(destination, row);
+      });
+      apply();
+    }
+    return {
+      dryRun,
+      source: plan.source,
+      migrated: plan.migrated,
+      skipped: plan.skipped,
+      conflicts: plan.conflicts,
+      snapshotsCreated: plan.snapshotsCreated,
+      backupCreated: !dryRun,
+      sourcePath,
+      destinationPath,
+      backupPath
+    };
+  } catch (error) {
+    if (error instanceof LegacyStoreMigrationError)
+      throw error;
+    throw new LegacyStoreMigrationError("MIGRATION_FAILED", `instructions legacy migration failed safely: ${error instanceof Error ? error.name : "unknown error"}`);
+  } finally {
+    source.close();
+    destination.close();
+  }
+}
+export {
+  migrateLegacyInstructionsStore,
+  legacyInstructionsStorePaths,
+  LegacyStoreMigrationError
+};

package/dist/chunks/{local-a9nen65z.js → local-5wvv5xv3.js}

@@ -14,12 +14,12 @@ import {
   normalizeOsFamily,
   normalizeProfileAssetBinding,
   normalizeProfileConfigBinding
-} from "./index-v7dkb384.js";
+} from "./index-4pfq42t5.js";
 import"./index-35z65jsa.js";
 import {
   ConfigNotFoundError,
   ProfileNotFoundError
-} from "./index-pkscjnj5.js";
+} from "./index-3djthcm6.js";
 import"./index-nnwp92tk.js";
 
 // src/db/database.ts

package/dist/chunks/{local-0d8qrc92.js → local-zxa5dpf4.js}

@@ -1,205 +1,30 @@
 // @bun
-import {
-  now,
-  slugify,
-  uuid
-} from "./index-ma2xmp6c.js";
 import {
   boundedReadPage,
   detectMachineContext,
-  getRawStoreRoot,
-  hasInstructionsEnvAuthorityIntent,
   legacyProfileConfigBinding,
   normalizeBoundedReadOptions,
   normalizeOsFamily,
   normalizeProfileAssetBinding,
   normalizeProfileConfigBinding
-} from "./index-1hpwskwd.js";
+} from "./index-7m4j8a33.js";
 import {
   ConfigNotFoundError,
   ProfileNotFoundError
-} from "./index-pkscjnj5.js";
+} from "./index-n3fjspr0.js";
+import {
+  getDatabase,
+  insertFeedback,
+  resetLocalDatabase
+} from "./index-5d7zdftc.js";
+import {
+  now,
+  slugify,
+  uuid
+} from "./index-ma2xmp6c.js";
+import"./index-fpeyzn3n.js";
 import"./index-bsan4c16.js";
 
-// src/db/database.ts
-import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync, rmSync } from "fs";
-import { join } from "path";
-function getDbPath() {
-  if (process.env["HASNA_INSTRUCTIONS_DB_PATH"]) {
-    return process.env["HASNA_INSTRUCTIONS_DB_PATH"];
-  }
-  const dir = getRawStoreRoot();
-  mkdirSync(dir, { recursive: true });
-  return join(dir, "instructions.db");
-}
-var MIGRATIONS = [
-  `
-  CREATE TABLE IF NOT EXISTS configs (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    slug TEXT NOT NULL UNIQUE,
-    kind TEXT NOT NULL DEFAULT 'file',
-    category TEXT NOT NULL,
-    agent TEXT NOT NULL DEFAULT 'global',
-    target_path TEXT,
-    format TEXT NOT NULL DEFAULT 'text',
-    content TEXT NOT NULL DEFAULT '',
-    description TEXT,
-    tags TEXT NOT NULL DEFAULT '[]',
-    is_template INTEGER NOT NULL DEFAULT 0,
-    version INTEGER NOT NULL DEFAULT 1,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    synced_at TEXT
-  );
-
-  CREATE TABLE IF NOT EXISTS config_snapshots (
-    id TEXT PRIMARY KEY,
-    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
-    content TEXT NOT NULL,
-    version INTEGER NOT NULL,
-    created_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS profiles (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    slug TEXT NOT NULL UNIQUE,
-    description TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS profile_configs (
-    profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
-    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
-    sort_order INTEGER NOT NULL DEFAULT 0,
-    PRIMARY KEY (profile_id, config_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS machines (
-    id TEXT PRIMARY KEY,
-    hostname TEXT NOT NULL UNIQUE,
-    os TEXT,
-    last_applied_at TEXT,
-    created_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS schema_version (
-    version INTEGER PRIMARY KEY
-  );
-
-  INSERT OR IGNORE INTO schema_version (version) VALUES (1);
-  `,
-  `
-  ALTER TABLE profiles ADD COLUMN selectors TEXT NOT NULL DEFAULT '{}';
-  ALTER TABLE profiles ADD COLUMN variables TEXT NOT NULL DEFAULT '{}';
-  ALTER TABLE machines ADD COLUMN arch TEXT;
-  `,
-  `
-  ALTER TABLE configs ADD COLUMN outputs TEXT NOT NULL DEFAULT '[]';
-  `,
-  `
-  ALTER TABLE profile_configs ADD COLUMN binding TEXT NOT NULL DEFAULT '{"schema":"hasna.instructions.profile-config-binding/v1","activation":{"mode":"always"},"required":true,"fallback":"fail"}';
-  `,
-  `
-  CREATE TABLE IF NOT EXISTS profile_assets (
-    profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
-    source_config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
-    asset_key TEXT NOT NULL,
-    sort_order INTEGER NOT NULL DEFAULT 0,
-    binding TEXT NOT NULL,
-    PRIMARY KEY (profile_id, asset_key)
-  );
-  CREATE INDEX IF NOT EXISTS profile_assets_source_config_idx ON profile_assets (source_config_id);
-  `
-];
-var _db = null;
-function getDatabase(path) {
-  if (_db)
-    return _db;
-  if (!path && hasInstructionsEnvAuthorityIntent(process.env)) {
-    throw new Error("instructions: refusing to open the on-box SQLite store \u2014 the environment configures a hosted " + "Instructions authority or credential (HASNA_INSTRUCTIONS_*), and reading or writing the local store " + "here would silently drift from the shared dataset. Pass an explicit database path (or an injected " + "Database) to work against the on-box store deliberately.");
-  }
-  const dbPath = path || getDbPath();
-  const db = new Database(dbPath);
-  db.run("PRAGMA journal_mode = WAL");
-  db.run("PRAGMA foreign_keys = ON");
-  applyMigrations(db);
-  ensureFeedbackTable(db);
-  _db = db;
-  return db;
-}
-function resetDatabase() {
-  if (_db) {
-    try {
-      _db.close();
-    } catch {}
-  }
-  _db = null;
-}
-function resetLocalDatabase() {
-  resetDatabase();
-  const dbPath = getDbPath();
-  if (dbPath === ":memory:")
-    return;
-  for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (existsSync(p))
-      rmSync(p);
-  }
-}
-function applyMigrations(db) {
-  let currentVersion = 0;
-  try {
-    const row = db.query("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
-    currentVersion = row?.version ?? 0;
-  } catch {
-    currentVersion = 0;
-  }
-  const applyOne = db.transaction((index) => {
-    if (!migrationEffectAlreadyPresent(db, index))
-      db.exec(MIGRATIONS[index]);
-    db.run(`INSERT OR REPLACE INTO schema_version (version) VALUES (${index + 1})`);
-  });
-  for (let i = currentVersion;i < MIGRATIONS.length; i++)
-    applyOne(i);
-}
-function migrationEffectAlreadyPresent(db, index) {
-  if (index !== 3)
-    return false;
-  return db.query("PRAGMA table_info(profile_configs)").all().some((column) => column.name === "binding");
-}
-function ensureFeedbackTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS feedback (
-      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
-      message TEXT NOT NULL,
-      email TEXT,
-      category TEXT DEFAULT 'general',
-      version TEXT,
-      machine_id TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )
-  `);
-  const existing = new Set(db.query("PRAGMA table_info(feedback)").all().map((r) => r.name));
-  const required = [
-    ["email", "TEXT"],
-    ["category", "TEXT DEFAULT 'general'"],
-    ["version", "TEXT"],
-    ["machine_id", "TEXT"],
-    ["created_at", "TEXT"]
-  ];
-  for (const [name, def] of required) {
-    if (!existing.has(name))
-      db.exec(`ALTER TABLE feedback ADD COLUMN ${name} ${def}`);
-  }
-}
-function insertFeedback(input, db) {
-  const d = db || getDatabase();
-  d.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [input.message, input.email ?? null, input.category ?? "general", input.version ?? null]);
-}
-
 // src/db/snapshots.ts
 function createSnapshot(configId, content, version, db) {
   const d = db || getDatabase();