@hasna/skills 0.1.44 → 0.1.46

package/bin/mcp.js

@@ -21797,7 +21797,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.44",
+  version: "0.1.46",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -21808,6 +21808,10 @@ var package_default = {
     ".": {
       import: "./dist/index.js",
       types: "./dist/index.d.ts"
+    },
+    "./storage": {
+      import: "./dist/storage.js",
+      types: "./dist/storage.d.ts"
     }
   },
   files: [
@@ -21828,7 +21832,7 @@ var package_default = {
   types: "./dist/index.d.ts",
   scripts: {
     clean: "rm -rf bin/ dist/",
-    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts ./src/storage.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
     test: "bun test",
     dev: "bun run ./src/cli/index.tsx",
     "dev:watch": "bun --watch run ./src/cli/index.tsx",
@@ -21858,9 +21862,11 @@ var package_default = {
   devDependencies: {
     "@types/bun": "latest",
     "@types/react": "^18.2.0",
+    "react-devtools-core": "^7.0.1",
     typescript: "^5"
   },
   dependencies: {
+    "@hasna/events": "^0.1.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -30115,12 +30121,47 @@ function ensurePortableSkillFiles(skillPath, manifest) {
     writeFileSync2(join3(skillPath, "skill.json"), renderSkillJson(next));
   if (!existsSync3(join3(skillPath, "AGENTS.md")))
     writeFileSync2(join3(skillPath, "AGENTS.md"), renderAgentsMd(next));
-  if (!existsSync3(join3(skillPath, "package.json")))
-    writeFileSync2(join3(skillPath, "package.json"), renderPackageJson(next));
+  ensurePackageJson(skillPath, next);
   if (!existsSync3(join3(skillPath, "tsconfig.json")))
     writeFileSync2(join3(skillPath, "tsconfig.json"), renderTsconfig());
   return readPortableSkillManifest(skillPath, next.name);
 }
+function ensurePackageJson(skillPath, manifest) {
+  const pkgPath = join3(skillPath, "package.json");
+  const first = manifest.commands[0] ?? { name: manifest.name, entry: "src/index.ts" };
+  const commandName = normalizePortableSkillName(first.name || manifest.name);
+  const entry = (first.entry ?? "src/index.ts").replace(/^\.\//, "");
+  if (!existsSync3(pkgPath)) {
+    writeFileSync2(pkgPath, renderPackageJson(manifest));
+    return;
+  }
+  const existing = readJsonObject(pkgPath);
+  const bin = {};
+  if (isRecord(existing.bin)) {
+    for (const [name, value] of Object.entries(existing.bin)) {
+      if (typeof value === "string" && value.trim())
+        bin[normalizePortableSkillName(name)] = value.replace(/^\.\//, "");
+    }
+  } else {
+    const binEntry = stringValue(existing.bin);
+    if (binEntry)
+      bin[manifest.name] = binEntry.replace(/^\.\//, "");
+  }
+  bin[commandName] = entry;
+  const scripts = isRecord(existing.scripts) ? { ...existing.scripts } : {};
+  if (!stringValue(scripts.dev))
+    scripts.dev = `bun run ${entry}`;
+  writeFileSync2(pkgPath, `${JSON.stringify({
+    ...existing,
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description,
+    type: stringValue(existing.type) ?? "module",
+    bin,
+    scripts
+  }, null, 2)}
+`);
+}
 function copySkillDirectory(source, destination) {
   mkdirSync2(destination, { recursive: true });
   cpSync(source, destination, {
@@ -33297,6 +33338,46 @@ var toolContracts = [
     inputSchema: objectSchema(),
     outputSchema: objectSchema({}, [], "Setup summary.", true)
   },
+  {
+    name: "storage_status",
+    title: "Storage Status",
+    description: "Show local-first storage paths and optional repo-owned Postgres/S3 readiness.",
+    params: ["directory?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ directory: stringSchema("Project directory.") }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      local: objectSchema({}, [], "Local storage paths.", true),
+      remote: objectSchema({}, [], "Remote storage readiness.", true)
+    }, ["package", "mode", "local", "remote"])
+  },
+  {
+    name: "storage_sync_plan",
+    title: "Storage Sync Plan",
+    description: "Plan .skills snapshot sync for optional Postgres/S3 storage without network access.",
+    params: ["directory?", "includeSchemaSql?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({
+      directory: stringSchema("Project directory."),
+      includeSchemaSql: { type: "boolean", default: false }
+    }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      noNetwork: { type: "boolean", const: true },
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      databaseConfigured: { type: "boolean" },
+      s3Configured: { type: "boolean" },
+      snapshotFileCount: { type: "number" },
+      s3ObjectCount: { type: "number" },
+      env: objectSchema({}, [], "Storage env var names.", true),
+      schemaSql: stringSchema("Optional Postgres schema SQL.")
+    }, ["package", "noNetwork", "mode", "databaseConfigured", "s3Configured"])
+  },
   {
     name: "schedule_skill",
     title: "Schedule Skill",
@@ -34923,6 +35004,266 @@ function registerScheduleTools(server) {
   });
 }
 
+// src/lib/native-storage.ts
+init_config();
+import { createHash as createHash2, createHmac } from "crypto";
+import {
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync6,
+  statSync as statSync5,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { dirname as dirname5, join as join13, normalize as normalize3, relative as relative3, sep } from "path";
+var SKILLS_STORAGE_TABLES = [
+  "skills_sync_records",
+  "skills_sync_cursors"
+];
+var SKILLS_NATIVE_STORAGE_ENV = {
+  mode: "HASNA_SKILLS_STORAGE_MODE",
+  databaseUrl: "HASNA_SKILLS_DATABASE_URL",
+  databaseSsl: "HASNA_SKILLS_DATABASE_SSL",
+  databaseSchema: "HASNA_SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "HASNA_SKILLS_S3_BUCKET",
+  s3Prefix: "HASNA_SKILLS_S3_PREFIX",
+  awsRegion: "HASNA_SKILLS_AWS_REGION",
+  s3Endpoint: "HASNA_SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "HASNA_SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "HASNA_SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "HASNA_SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "HASNA_SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "HASNA_SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "HASNA_SKILLS_SYNC_DRY_RUN"
+};
+var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
+  mode: "SKILLS_STORAGE_MODE",
+  databaseUrl: "SKILLS_DATABASE_URL",
+  databaseSsl: "SKILLS_DATABASE_SSL",
+  databaseSchema: "SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "SKILLS_S3_BUCKET",
+  s3Prefix: "SKILLS_S3_PREFIX",
+  awsRegion: "SKILLS_AWS_REGION",
+  s3Endpoint: "SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "SKILLS_SYNC_DRY_RUN"
+};
+function resolveSkillsNativeStorageConfig(env = process.env) {
+  const mode = getSkillsStorageMode(env);
+  return {
+    mode,
+    databaseUrl: getSkillsStorageDatabaseUrl(env),
+    databaseSsl: parseBoolean(readStorageEnv(env, "databaseSsl").value),
+    databaseSchema: readStorageEnv(env, "databaseSchema").value,
+    s3Bucket: readStorageEnv(env, "s3Bucket").value,
+    s3Prefix: readStorageEnv(env, "s3Prefix").value,
+    awsRegion: readStorageEnv(env, "awsRegion").value ?? "us-east-1",
+    s3Endpoint: readStorageEnv(env, "s3Endpoint").value,
+    s3ForcePathStyle: parseBoolean(readStorageEnv(env, "s3ForcePathStyle").value) ?? false,
+    syncBatchSize: parsePositiveInteger(readStorageEnv(env, "syncBatchSize").value) ?? 500,
+    dryRun: parseBoolean(readStorageEnv(env, "dryRun").value) ?? true
+  };
+}
+function resolveStorageConfig(env = process.env) {
+  return resolveSkillsNativeStorageConfig(env);
+}
+function getSkillsStorageMode(env = process.env) {
+  return parseMode(readStorageEnv(env, "mode").value);
+}
+function getSkillsStorageDatabaseUrl(env = process.env) {
+  return readStorageEnv(env, "databaseUrl").value;
+}
+function getSkillsNativeStorageStatus(options = {}) {
+  const env = options.env ?? process.env;
+  const config2 = resolveSkillsNativeStorageConfig(env);
+  const modeEnv = readStorageEnv(env, "mode");
+  const databaseEnv = readStorageEnv(env, "databaseUrl");
+  const s3BucketEnv = readStorageEnv(env, "s3Bucket");
+  const targetDir = options.targetDir ?? process.cwd();
+  return {
+    package: "open-skills",
+    mode: config2.mode,
+    tables: [...SKILLS_STORAGE_TABLES],
+    env: {
+      mode: SKILLS_NATIVE_STORAGE_ENV.mode,
+      databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
+    },
+    local: {
+      dataDir: getDataDir(),
+      projectStateDir: getProjectStateDir(targetDir),
+      feedbackDbPath: join13(getDataDir(), "skills.db")
+    },
+    remote: {
+      databaseConfigured: Boolean(config2.databaseUrl),
+      s3Configured: Boolean(config2.s3Bucket),
+      databaseEnv: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3BucketEnv: SKILLS_NATIVE_STORAGE_ENV.s3Bucket,
+      activeModeEnv: modeEnv.name,
+      activeDatabaseEnv: databaseEnv.name,
+      activeS3BucketEnv: s3BucketEnv.name,
+      region: config2.awsRegion ?? "us-east-1",
+      dryRun: config2.dryRun
+    }
+  };
+}
+function getStorageStatus(options = {}) {
+  return getSkillsNativeStorageStatus(options);
+}
+function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
+  const projectStateDir = getProjectStateDir(targetDir);
+  const files = [];
+  if (existsSync13(projectStateDir)) {
+    for (const filePath of walkFiles2(projectStateDir)) {
+      const bytes = readFileSync11(filePath);
+      const relativePath = toPosix(relative3(targetDir, filePath));
+      files.push({
+        path: relativePath,
+        sizeBytes: bytes.byteLength,
+        sha256: createHash2("sha256").update(bytes).digest("hex"),
+        ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
+      });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    files: files.sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+var skillsPostgresSyncSchemaSql = `
+CREATE TABLE IF NOT EXISTS skills_sync_records (
+  scope TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  id TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  deleted_at TIMESTAMPTZ,
+  source TEXT,
+  payload JSONB NOT NULL,
+  PRIMARY KEY (scope, kind, id)
+);
+
+CREATE INDEX IF NOT EXISTS skills_sync_records_updated_at_idx
+  ON skills_sync_records (updated_at);
+
+CREATE TABLE IF NOT EXISTS skills_sync_cursors (
+  scope TEXT NOT NULL,
+  cursor_name TEXT NOT NULL,
+  value TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (scope, cursor_name)
+);
+`.trim();
+function planSkillsS3SnapshotUpload(snapshot, options = {}) {
+  const prefix = normalizeS3Prefix(options.prefix);
+  return snapshot.files.map((file2) => ({
+    path: file2.path,
+    key: [prefix, file2.path.replace(/^\.?\//, "")].filter(Boolean).join("/"),
+    sizeBytes: file2.sizeBytes,
+    sha256: file2.sha256
+  }));
+}
+function parseMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "remote" || normalized === "hybrid")
+    return normalized;
+  return "local";
+}
+function readStorageEnv(env, key) {
+  const primaryName = SKILLS_NATIVE_STORAGE_ENV[key];
+  const primaryValue = cleanOptional(env[primaryName]);
+  if (primaryValue !== undefined)
+    return { name: primaryName, value: primaryValue };
+  const fallbackName = SKILLS_NATIVE_STORAGE_FALLBACK_ENV[key];
+  const fallbackValue = cleanOptional(env[fallbackName]);
+  if (fallbackValue !== undefined)
+    return { name: fallbackName, value: fallbackValue };
+  return { name: primaryName };
+}
+function cleanOptional(value) {
+  const cleaned = value?.trim();
+  return cleaned ? cleaned : undefined;
+}
+function parseBoolean(value) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized))
+    return true;
+  if (["0", "false", "no", "off"].includes(normalized))
+    return false;
+  return;
+}
+function parsePositiveInteger(value) {
+  if (!value)
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function walkFiles2(dir) {
+  const files = [];
+  for (const entry of readdirSync6(dir)) {
+    const full = join13(dir, entry);
+    const stats = statSync5(full);
+    if (stats.isDirectory())
+      files.push(...walkFiles2(full));
+    else
+      files.push(full);
+  }
+  return files;
+}
+function normalizeS3Prefix(prefix) {
+  return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
+}
+function toPosix(path) {
+  return path.split(/[\\/]+/).join("/");
+}
+
+// src/mcp/storage-tools.ts
+function registerStorageTools(server) {
+  server.registerTool("storage_status", {
+    title: "Storage Status",
+    description: "Show local-first storage paths and optional repo-owned Postgres/S3 readiness.",
+    inputSchema: {
+      directory: exports_external.string().optional()
+    }
+  }, async ({ directory }) => {
+    return mcpJson(getStorageStatus({ targetDir: directory || process.cwd() }), true);
+  });
+  server.registerTool("storage_sync_plan", {
+    title: "Storage Sync Plan",
+    description: "Plan .skills snapshot sync for optional Postgres/S3 storage without network access.",
+    inputSchema: {
+      directory: exports_external.string().optional(),
+      includeSchemaSql: exports_external.boolean().optional()
+    }
+  }, async ({ directory, includeSchemaSql }) => {
+    const targetDir = directory || process.cwd();
+    const config2 = resolveStorageConfig();
+    const snapshot = exportSkillsLocalSnapshot(targetDir, { includeFileContents: false });
+    const s3Plan = config2.s3Bucket ? planSkillsS3SnapshotUpload(snapshot, { prefix: config2.s3Prefix }) : [];
+    return mcpJson({
+      package: "open-skills",
+      noNetwork: true,
+      mode: config2.mode,
+      databaseConfigured: Boolean(config2.databaseUrl),
+      s3Configured: Boolean(config2.s3Bucket),
+      snapshotFileCount: snapshot.files.length,
+      s3ObjectCount: s3Plan.length,
+      env: {
+        mode: SKILLS_NATIVE_STORAGE_ENV.mode,
+        databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+        s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
+      },
+      ...includeSchemaSql ? { schemaSql: skillsPostgresSyncSchemaSql } : {}
+    }, true);
+  });
+}
+
 // src/mcp/server.ts
 function buildServer() {
   const server = new McpServer({
@@ -34932,6 +35273,7 @@ function buildServer() {
   registerDiscoveryTools(server);
   registerOperationTools(server);
   registerScheduleTools(server);
+  registerStorageTools(server);
   registerResourceMetaTools(server);
   return server;
 }

package/dist/cli/commands/storage.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerStorage(parent: Command): void;

package/dist/index.d.ts

@@ -25,5 +25,6 @@ export { SKILLS_CLI_MCP_PARITY, findSkillsParityForCliCommand, findSkillsParityF
 export { createRegistrySyncArtifact, writeRegistrySyncArtifact, type RegistrySyncArtifact, type RegistrySyncOptions, type RegistrySyncSkill, } from "./lib/registry-sync.js";
 export { MCP_CONTRACT_SCHEMA_VERSION, createMcpContractManifest, createSkillMcpMetadata, describeMcpToolContracts, getMcpResourceContracts, getMcpToolDescriptions, listMcpToolContracts, summarizeMcpToolContract, type DescribedMcpToolContract, type JsonSchemaObject, type McpContractManifest, type McpResourceContract, type McpToolCategory, type McpToolContract, type McpToolSideEffect, type SkillMcpMetadata, type SkillMcpSchemaContract, type UnknownMcpToolContract, } from "./lib/mcp-contracts.js";
 export { getFeedbackDbPath, saveFeedback, type FeedbackCategory, type FeedbackInput, type FeedbackResult, } from "./lib/feedback.js";
+export { SKILLS_NATIVE_STORAGE_ENV, SKILLS_NATIVE_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_ENV, SKILLS_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_TABLES, STORAGE_TABLES, SkillsPostgresSyncStore, SkillsS3ObjectStore, buildSkillsS3ObjectUrl, createSkillsPostgresSyncStore, createSkillsS3ObjectStore, createSkillsSnapshotSyncRecord, exportSkillsLocalSnapshot, getSkillsNativeStorageStatus, getSkillsStorageDatabaseEnv, getSkillsStorageDatabaseUrl, getSkillsStorageMode, getSkillsStorageStatus, getStorageDatabaseEnv, getStorageDatabaseUrl, getStorageMode, getStorageStatus, importSkillsLocalSnapshot, planSkillsS3SnapshotUpload, resolveSkillsNativeStorageConfig, resolveStorageConfig, signSkillsAwsV4Request, skillsPostgresSyncSchemaSql, uploadSkillsSnapshotFilesToS3, type AwsCredentials, type SignSkillsAwsV4RequestOptions, type SkillsFetch, type SkillsLocalSnapshot, type SkillsNativeStorageConfig, type SkillsNativeStorageStatus, type SkillsPostgresQueryClient, type SkillsS3ObjectStoreOptions, type SkillsS3PutObjectOptions, type SkillsS3SnapshotPlanEntry, type SkillsS3StoredObject, type SkillsSnapshotFile, type SkillsStorageMode, type SkillsStorageTable, type SkillsSyncRecord, } from "./lib/native-storage.js";
 export { SKILL_ALIASES, normalizeSkillSlug, resolveSkillAlias, type SkillAlias, } from "./lib/skill-aliases.js";
 export type { SkillResponse, SkillDetailResponse, CategoryResponse, TagResponse, InstallResponse, RemoveResponse, VersionResponse, ExportResponse, ImportResponse, SearchResponse, CategoryInstallResponse, ErrorResponse, } from "./types/api.js";