@hasna/skills 0.1.71 → 0.1.72

package/bin/migrate.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/server/migrate.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
 
 // src/lib/retired-settings.ts
 var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
@@ -81,65 +81,174 @@ function normalizePrefix(value) {
 }
 
 // src/server/database-url.ts
-import { isAbsolute, join as join2 } from "path";
+import { isAbsolute, join as join4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/lib/app-home.ts
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve } from "path";
+
+// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
 import { homedir } from "os";
+import { join } from "path";
+var KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function assertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function envOf(options) {
+  return options.env ?? process.env;
+}
+function envValue(options, kind) {
+  const value = envOf(options)[KIND_ENV[kind]];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isMacOS(platform) {
+  return platform === "darwin";
+}
+function baseDir(kind, options) {
+  const override = envValue(options, kind);
+  if (override)
+    return override;
+  const home = options.home ?? homedir();
+  const platform = options.platform ?? process.platform;
+  if (isMacOS(platform)) {
+    switch (kind) {
+      case "config":
+      case "data":
+        return join(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return join(home, "Library", "Caches", "Hasna");
+      case "state":
+        return join(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return join(home, ".config", "hasna");
+    case "data":
+      return join(home, ".local", "share", "hasna");
+    case "state":
+      return join(home, ".local", "state", "hasna");
+    case "cache":
+      return join(home, ".cache", "hasna");
+  }
+}
+function resolvePath(kind, options) {
+  assertApp(options.app);
+  const appSegment = options.internal === true ? join("internal", options.app) : options.app;
+  return join(baseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return resolvePath("data", options);
+}
+
+// src/lib/app-home.ts
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+var HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME";
+var SKILLS_HOME_ENV = "SKILLS_HOME";
+var DEFAULT_SQLITE_FILENAME = "server.db";
+var GLOBAL_CONFIG_FILENAME = "config.json";
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir2() || "/tmp";
+}
+function legacyDataRoot() {
+  return join2(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome()) {
+  return dataDir({ app: "skills", home });
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join2(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join2(resolved, GLOBAL_CONFIG_FILENAME));
+}
+function exactDataRoot() {
+  for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
+    const dir = process.env[key]?.trim();
+    if (dir)
+      return resolve(dir);
+  }
+  return;
+}
+function hasExactOverride(env = process.env) {
+  return Boolean(env[DATA_DIR_ENV]?.trim()) || Boolean(env[HASNA_SKILLS_HOME_ENV]?.trim()) || Boolean(env[SKILLS_HOME_ENV]?.trim());
+}
+function hasOperatorOverride(env = process.env) {
+  return hasExactOverride(env) || Boolean(env.HASNA_DATA_HOME?.trim());
+}
+function getDataRoot() {
+  const exact = exactDataRoot();
+  if (exact)
+    return exact;
+  const resolved = resolverDataRoot();
+  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
+}
+// src/lib/config.ts
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync(sourceDir))
+  if (!existsSync2(sourceDir))
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join(sourceDir, entry);
-    const targetPath = join(targetDir, entry);
+    const sourcePath = join3(sourceDir, entry);
+    const targetPath = join3(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync(targetPath))
+      if (!existsSync2(targetPath))
         copyFileSync(sourcePath, targetPath);
     } catch {}
   }
 }
-var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
 function getDataDir() {
-  const override = process.env[DATA_DIR_ENV];
-  if (override) {
-    try {
-      mkdirSync(override, { recursive: true });
-    } catch {}
-    return override;
-  }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const newDir = join(home, ".hasna", "skills");
-  const oldDir = join(home, ".skills");
-  const oldConfigFile = join(home, ".skillsrc");
-  mkdirSync(newDir, { recursive: true });
+  const root = getDataRoot();
+  try {
+    mkdirSync(root, { recursive: true });
+  } catch {}
+  if (hasOperatorOverride())
+    return root;
+  const home = effectiveHome();
+  const oldDir = join3(home, ".skills");
+  const oldConfigFile = join3(home, ".skillsrc");
   try {
-    mergeDirectoryContents(oldDir, newDir);
+    mergeDirectoryContents(oldDir, root);
   } catch {}
-  if (existsSync(oldConfigFile) && !existsSync(join(newDir, "config.json"))) {
+  if (existsSync2(oldConfigFile) && !existsSync2(join3(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join3(root, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root;
 }
 
 // src/server/database-url.ts
-var DEFAULT_SQLITE_FILENAME = "server.db";
+var DEFAULT_SQLITE_FILENAME2 = "server.db";
 var SQLITE_MEMORY_PATH = ":memory:";
 var POSTGRES_SCHEMES = new Set(["postgres", "postgresql"]);
 var SQLITE_SCHEMES = new Set(["sqlite", "sqlite3", "file"]);
 var MEMORY_SCHEMES = new Set(["memory"]);
 var SQLITE_EXTENSIONS = [".db", ".sqlite", ".sqlite3", ".db3"];
 function defaultSqlitePath() {
-  return join2(getDataDir(), DEFAULT_SQLITE_FILENAME);
+  return join4(getDataDir(), DEFAULT_SQLITE_FILENAME2);
 }
 function resolveDatabaseTarget(raw) {
   const value = raw?.trim();
@@ -166,7 +275,7 @@ function resolveDatabaseTarget(raw) {
     throw new Error(`unsupported database scheme "${scheme}:". Supported: postgres://, postgresql://, sqlite:, file:, ` + `an absolute or relative path to a .db/.sqlite file, ":memory:", or "memory:" (non-durable, tests only). ` + `Leave the setting empty to use the default SQLite database at ${defaultSqlitePath()}.`);
   }
   if (looksLikeSqlitePath(value)) {
-    const path = isAbsolute(value) ? value : join2(process.cwd(), value);
+    const path = isAbsolute(value) ? value : join4(process.cwd(), value);
     return { kind: "sqlite", path, durable: true, label: `sqlite (${path})` };
   }
   throw new Error(`could not resolve a database backend from "${value}". Use postgres://\u2026, sqlite:\u2026, an absolute or ` + `relative path ending in ${SQLITE_EXTENSIONS.join("/")}, ":memory:", or leave it empty for the ` + `default SQLite database at ${defaultSqlitePath()}.`);
@@ -190,7 +299,7 @@ function sqlitePathFromUrl(value, scheme) {
     }
     return rest.slice(2).replace(/^\/\/+/, "/");
   }
-  return isAbsolute(rest) ? rest : join2(process.cwd(), rest);
+  return isAbsolute(rest) ? rest : join4(process.cwd(), rest);
 }
 function looksLikeSqlitePath(value) {
   if (value.includes("/"))
@@ -199,16 +308,16 @@ function looksLikeSqlitePath(value) {
 }
 
 // src/server/migrations-dir.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
 var MIGRATION_DIALECTS = ["postgres", "sqlite"];
 var MAX_WALK_UP = 6;
 function findMigrationsRoot(startDirs = defaultStartDirs()) {
   for (const start of startDirs) {
     let dir = start;
     for (let level = 0;level < MAX_WALK_UP; level += 1) {
-      const candidate = join3(dir, "migrations");
-      if (MIGRATION_DIALECTS.some((dialect) => existsSync2(join3(candidate, dialect))))
+      const candidate = join5(dir, "migrations");
+      if (MIGRATION_DIALECTS.some((dialect) => existsSync3(join5(candidate, dialect))))
         return candidate;
       const parent = dirname2(dir);
       if (parent === dir)
@@ -222,8 +331,8 @@ function resolveMigrationsDir(dialect, root = findMigrationsRoot()) {
   if (!root) {
     throw new Error(`could not locate the migrations directory for dialect "${dialect}". ` + `Expected a migrations/${dialect}/ folder alongside the package root.`);
   }
-  const dir = join3(root, dialect);
-  if (!existsSync2(dir)) {
+  const dir = join5(root, dialect);
+  if (!existsSync3(dir)) {
     throw new Error(`migrations directory not found: ${dir}`);
   }
   return dir;
@@ -240,7 +349,7 @@ function defaultStartDirs() {
 import { Database } from "bun:sqlite";
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 
 // src/server/auth.ts
 import { createHash } from "crypto";
@@ -1119,7 +1228,7 @@ function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite"
   const appliedNow = [];
   for (const file of files) {
     const version = file.replace(/\.sql$/, "");
-    const text = readFileSync2(join4(migrationsDir, file), "utf8");
+    const text = readFileSync2(join6(migrationsDir, file), "utf8");
     const apply = db.transaction(() => {
       const already = db.query("SELECT 1 AS present FROM schema_migrations WHERE version = ? LIMIT 1").get(version);
       if (already)
@@ -1192,7 +1301,7 @@ async function runMigrations(databaseUrl, migrationsDir) {
   return { backend: "postgres", applied: await runPostgresMigrations(target.url, migrationsDir ?? resolveMigrationsDir("postgres")) };
 }
 async function runPostgresMigrations(databaseUrl, migrationsDir) {
-  if (!existsSync3(migrationsDir))
+  if (!existsSync4(migrationsDir))
     throw new Error(`migrations directory not found: ${migrationsDir}`);
   const bunWithSql = Bun;
   const sql = new bunWithSql.SQL(databaseUrl, { max: 1 });
@@ -1208,7 +1317,7 @@ async function runPostgresMigrations(databaseUrl, migrationsDir) {
       const version = file.replace(/\.sql$/, "");
       if (applied.has(version))
         continue;
-      const sqlText = readFileSync3(join5(migrationsDir, file), "utf8");
+      const sqlText = readFileSync3(join7(migrationsDir, file), "utf8");
       await sql.unsafe("BEGIN");
       try {
         await sql.unsafe(sqlText);