@kodax-ai/kodax 0.7.95 → 0.7.96-alpha.2

package/dist/builtin/skill-creator/scripts/install-skill.js

@@ -1,177 +1,177 @@
-#!/usr/bin/env node
-
-import { cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { strFromU8, unzipSync } from 'fflate';
-import { validateSkillDirectory } from './quick-validate.js';
-import { getDefaultSkillsDir, parseSkillMarkdown, pathExists } from './utils.js';
-
-const PACKAGE_MANIFEST_PATH = '.kodax-package.json';
-
-function normalizeArchivePath(relativePath) {
-  return relativePath.replace(/\\/g, '/').replace(/^\.?\//, '');
-}
-
-function assertSafeArchivePath(relativePath) {
-  const normalized = normalizeArchivePath(relativePath);
-  if (!normalized || normalized.startsWith('/') || normalized.includes('../')) {
-    throw new Error(`Unsafe archive entry path: ${relativePath}`);
-  }
-  return normalized;
-}
-
-function isZipLike(filePath) {
-  return /\.(skill|zip)$/i.test(filePath);
-}
-
-export function readSkillPackageBuffer(buffer) {
-  const archive = unzipSync(buffer);
-  const entries = Object.entries(archive).map(([relativePath, bytes]) => ({
-    relativePath: assertSafeArchivePath(relativePath),
-    bytes,
-  }));
-
-  const skillEntry = entries.find((entry) => entry.relativePath === 'SKILL.md');
-  if (!skillEntry) {
-    throw new Error('Archive is missing SKILL.md');
-  }
-
-  const parsedSkill = parseSkillMarkdown(strFromU8(skillEntry.bytes));
-  const skillName = typeof parsedSkill.frontmatter.name === 'string'
-    ? parsedSkill.frontmatter.name.trim()
-    : '';
-  const description = typeof parsedSkill.frontmatter.description === 'string'
-    ? parsedSkill.frontmatter.description.trim()
-    : '';
-  if (!skillName || !description) {
-    throw new Error('Archive SKILL.md is missing required frontmatter fields.');
-  }
-
-  const manifestEntry = entries.find((entry) => entry.relativePath === PACKAGE_MANIFEST_PATH);
-  const manifest = manifestEntry
-    ? JSON.parse(strFromU8(manifestEntry.bytes))
-    : null;
-
-  return {
-    skillName,
-    manifest,
-    entries: entries.filter((entry) => entry.relativePath !== PACKAGE_MANIFEST_PATH),
-  };
-}
-
-async function ensureInstallTarget(targetDir, force) {
-  if (await pathExists(targetDir)) {
-    if (!force) {
-      throw new Error(`Target skill already exists: ${targetDir}`);
-    }
-    await rm(targetDir, { recursive: true, force: true });
-  }
-  await mkdir(targetDir, { recursive: true });
-}
-
-export async function installSkillArchive(archivePath, options = {}) {
-  const skillsDir = path.resolve(options.skillsDir ?? getDefaultSkillsDir());
-  const archive = readSkillPackageBuffer(await readFile(archivePath));
-  const targetDir = path.join(skillsDir, archive.skillName);
-  await ensureInstallTarget(targetDir, options.force === true);
-
-  for (const entry of archive.entries) {
-    const destination = path.join(targetDir, entry.relativePath);
-    await mkdir(path.dirname(destination), { recursive: true });
-    await writeFile(destination, entry.bytes);
-  }
-
-  return {
-    skillName: archive.skillName,
-    installedTo: targetDir,
-    source: path.resolve(archivePath),
-    manifest: archive.manifest,
-  };
-}
-
-export async function installSkillDirectory(skillDir, options = {}) {
-  const validation = await validateSkillDirectory(skillDir);
-  if (!validation.valid) {
-    throw new Error(`Cannot install invalid skill:\n- ${validation.errors.join('\n- ')}`);
-  }
-
-  const skillFilePath = path.join(skillDir, 'SKILL.md');
-  const skill = parseSkillMarkdown(await readFile(skillFilePath, 'utf8'));
-  const skillsDir = path.resolve(options.skillsDir ?? getDefaultSkillsDir());
-  const targetDir = path.join(skillsDir, skill.frontmatter.name);
-  if (await pathExists(targetDir)) {
-    if (!options.force) {
-      throw new Error(`Target skill already exists: ${targetDir}`);
-    }
-    await rm(targetDir, { recursive: true, force: true });
-  }
-  await mkdir(skillsDir, { recursive: true });
-  await cp(skillDir, targetDir, { recursive: true });
-
-  return {
-    skillName: skill.frontmatter.name,
-    installedTo: targetDir,
-    source: path.resolve(skillDir),
-    manifest: null,
-  };
-}
-
-export async function installSkill(inputPath, options = {}) {
-  const resolvedInput = path.resolve(inputPath);
-  const inputStat = await stat(resolvedInput).catch(() => null);
-  if (!inputStat) {
-    throw new Error(`Input not found: ${resolvedInput}`);
-  }
-
-  if (inputStat.isDirectory()) {
-    return installSkillDirectory(resolvedInput, options);
-  }
-
-  if (inputStat.isFile() && isZipLike(resolvedInput)) {
-    return installSkillArchive(resolvedInput, options);
-  }
-
-  throw new Error('Input must be a skill directory or a .skill/.zip archive.');
-}
-
-function parseArgs(argv) {
-  const args = {
-    input: argv[2],
-    skillsDir: undefined,
-    force: false,
-  };
-
-  for (let index = 3; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (token === '--dest' && argv[index + 1]) {
-      args.skillsDir = argv[++index];
-    } else if (token === '--force') {
-      args.force = true;
-    }
-  }
-
-  return args;
-}
-
+#!/usr/bin/env node
+
+import { cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { strFromU8, unzipSync } from 'fflate';
+import { validateSkillDirectory } from './quick-validate.js';
+import { getDefaultSkillsDir, parseSkillMarkdown, pathExists } from './utils.js';
+
+const PACKAGE_MANIFEST_PATH = '.kodax-package.json';
+
+function normalizeArchivePath(relativePath) {
+  return relativePath.replace(/\\/g, '/').replace(/^\.?\//, '');
+}
+
+function assertSafeArchivePath(relativePath) {
+  const normalized = normalizeArchivePath(relativePath);
+  if (!normalized || normalized.startsWith('/') || normalized.includes('../')) {
+    throw new Error(`Unsafe archive entry path: ${relativePath}`);
+  }
+  return normalized;
+}
+
+function isZipLike(filePath) {
+  return /\.(skill|zip)$/i.test(filePath);
+}
+
+export function readSkillPackageBuffer(buffer) {
+  const archive = unzipSync(buffer);
+  const entries = Object.entries(archive).map(([relativePath, bytes]) => ({
+    relativePath: assertSafeArchivePath(relativePath),
+    bytes,
+  }));
+
+  const skillEntry = entries.find((entry) => entry.relativePath === 'SKILL.md');
+  if (!skillEntry) {
+    throw new Error('Archive is missing SKILL.md');
+  }
+
+  const parsedSkill = parseSkillMarkdown(strFromU8(skillEntry.bytes));
+  const skillName = typeof parsedSkill.frontmatter.name === 'string'
+    ? parsedSkill.frontmatter.name.trim()
+    : '';
+  const description = typeof parsedSkill.frontmatter.description === 'string'
+    ? parsedSkill.frontmatter.description.trim()
+    : '';
+  if (!skillName || !description) {
+    throw new Error('Archive SKILL.md is missing required frontmatter fields.');
+  }
+
+  const manifestEntry = entries.find((entry) => entry.relativePath === PACKAGE_MANIFEST_PATH);
+  const manifest = manifestEntry
+    ? JSON.parse(strFromU8(manifestEntry.bytes))
+    : null;
+
+  return {
+    skillName,
+    manifest,
+    entries: entries.filter((entry) => entry.relativePath !== PACKAGE_MANIFEST_PATH),
+  };
+}
+
+async function ensureInstallTarget(targetDir, force) {
+  if (await pathExists(targetDir)) {
+    if (!force) {
+      throw new Error(`Target skill already exists: ${targetDir}`);
+    }
+    await rm(targetDir, { recursive: true, force: true });
+  }
+  await mkdir(targetDir, { recursive: true });
+}
+
+export async function installSkillArchive(archivePath, options = {}) {
+  const skillsDir = path.resolve(options.skillsDir ?? getDefaultSkillsDir());
+  const archive = readSkillPackageBuffer(await readFile(archivePath));
+  const targetDir = path.join(skillsDir, archive.skillName);
+  await ensureInstallTarget(targetDir, options.force === true);
+
+  for (const entry of archive.entries) {
+    const destination = path.join(targetDir, entry.relativePath);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(destination, entry.bytes);
+  }
+
+  return {
+    skillName: archive.skillName,
+    installedTo: targetDir,
+    source: path.resolve(archivePath),
+    manifest: archive.manifest,
+  };
+}
+
+export async function installSkillDirectory(skillDir, options = {}) {
+  const validation = await validateSkillDirectory(skillDir);
+  if (!validation.valid) {
+    throw new Error(`Cannot install invalid skill:\n- ${validation.errors.join('\n- ')}`);
+  }
+
+  const skillFilePath = path.join(skillDir, 'SKILL.md');
+  const skill = parseSkillMarkdown(await readFile(skillFilePath, 'utf8'));
+  const skillsDir = path.resolve(options.skillsDir ?? getDefaultSkillsDir());
+  const targetDir = path.join(skillsDir, skill.frontmatter.name);
+  if (await pathExists(targetDir)) {
+    if (!options.force) {
+      throw new Error(`Target skill already exists: ${targetDir}`);
+    }
+    await rm(targetDir, { recursive: true, force: true });
+  }
+  await mkdir(skillsDir, { recursive: true });
+  await cp(skillDir, targetDir, { recursive: true });
+
+  return {
+    skillName: skill.frontmatter.name,
+    installedTo: targetDir,
+    source: path.resolve(skillDir),
+    manifest: null,
+  };
+}
+
+export async function installSkill(inputPath, options = {}) {
+  const resolvedInput = path.resolve(inputPath);
+  const inputStat = await stat(resolvedInput).catch(() => null);
+  if (!inputStat) {
+    throw new Error(`Input not found: ${resolvedInput}`);
+  }
+
+  if (inputStat.isDirectory()) {
+    return installSkillDirectory(resolvedInput, options);
+  }
+
+  if (inputStat.isFile() && isZipLike(resolvedInput)) {
+    return installSkillArchive(resolvedInput, options);
+  }
+
+  throw new Error('Input must be a skill directory or a .skill/.zip archive.');
+}
+
+function parseArgs(argv) {
+  const args = {
+    input: argv[2],
+    skillsDir: undefined,
+    force: false,
+  };
+
+  for (let index = 3; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--dest' && argv[index + 1]) {
+      args.skillsDir = argv[++index];
+    } else if (token === '--force') {
+      args.force = true;
+    }
+  }
+
+  return args;
+}
+
 export async function main(argv = process.argv) {
   const args = parseArgs(argv);
-  if (!args.input) {
-    console.error('Usage: node scripts/install-skill.js <skill-dir-or-archive> [--dest <skills-dir>] [--force]');
-    process.exit(1);
-  }
-
-  const result = await installSkill(args.input, args);
-  console.log(`Installed ${result.skillName} to ${result.installedTo}`);
-}
-
+  if (!args.input) {
+    console.error('Usage: node scripts/install-skill.js <skill-dir-or-archive> [--dest <skills-dir>] [--force]');
+    process.exit(1);
+  }
+
+  const result = await installSkill(args.input, args);
+  console.log(`Installed ${result.skillName} to ${result.installedTo}`);
+}
+
 const isDirectRun = process.env.KODAX_MODULE_BUNDLE !== 'true'
   && process.argv[1]
-  && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-
-if (isDirectRun) {
-  main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  });
-}
+  && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+
+if (isDirectRun) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}

package/dist/builtin/skill-creator/scripts/package-skill.d.ts

@@ -1,39 +1,39 @@
-export interface PackagedSkillFile {
-  path: string;
-  size: number;
-  sha256: string;
-}
-
-export interface SkillPackageManifest {
-  format: 'kodax-skill-package';
-  version: 1;
-  created_at: string;
-  entrypoint: 'SKILL.md';
-  skill: {
-    name: string;
-    description: string;
-    compatibility: string | null;
-    user_invocable: boolean;
-    disable_model_invocation: boolean;
-  };
-  files: PackagedSkillFile[];
-  note: string;
-}
-
-export function createPackageManifest(
-  skill: { frontmatter: Record<string, unknown> },
-  files: Array<{ relativePath: string; bytes: Uint8Array; sha256: string }>,
-  options?: { createdAt?: string }
-): SkillPackageManifest;
-
-export function buildSkillPackage(
-  skillDir: string,
-  options?: { createdAt?: string }
-): Promise<{ manifest: SkillPackageManifest; bytes: Uint8Array }>;
-
-export function writeSkillPackage(
-  skillDir: string,
-  outputPath: string,
-  options?: { createdAt?: string }
-): Promise<{ manifest: SkillPackageManifest; bytes: Uint8Array; outputPath: string }>;
+export interface PackagedSkillFile {
+  path: string;
+  size: number;
+  sha256: string;
+}
+
+export interface SkillPackageManifest {
+  format: 'kodax-skill-package';
+  version: 1;
+  created_at: string;
+  entrypoint: 'SKILL.md';
+  skill: {
+    name: string;
+    description: string;
+    compatibility: string | null;
+    user_invocable: boolean;
+    disable_model_invocation: boolean;
+  };
+  files: PackagedSkillFile[];
+  note: string;
+}
+
+export function createPackageManifest(
+  skill: { frontmatter: Record<string, unknown> },
+  files: Array<{ relativePath: string; bytes: Uint8Array; sha256: string }>,
+  options?: { createdAt?: string }
+): SkillPackageManifest;
+
+export function buildSkillPackage(
+  skillDir: string,
+  options?: { createdAt?: string }
+): Promise<{ manifest: SkillPackageManifest; bytes: Uint8Array }>;
+
+export function writeSkillPackage(
+  skillDir: string,
+  outputPath: string,
+  options?: { createdAt?: string }
+): Promise<{ manifest: SkillPackageManifest; bytes: Uint8Array; outputPath: string }>;
 export declare function main(argv?: string[]): Promise<void>;

package/dist/builtin/skill-creator/scripts/package-skill.js

@@ -1,125 +1,125 @@
-#!/usr/bin/env node
-
-import { readFile, writeFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { zipSync, strToU8 } from 'fflate';
-import { validateSkillDirectory } from './quick-validate.js';
-import { collectFiles, loadSkill } from './utils.js';
-
-const PACKAGE_MANIFEST_PATH = '.kodax-package.json';
-
-function toUint8Array(value) {
-  return value instanceof Uint8Array ? value : new Uint8Array(value);
-}
-
-function sha256(buffer) {
-  return createHash('sha256').update(buffer).digest('hex');
-}
-
-export function createPackageManifest(skill, files, options = {}) {
-  return {
-    format: 'kodax-skill-package',
-    version: 1,
-    created_at: options.createdAt ?? new Date().toISOString(),
-    entrypoint: 'SKILL.md',
-    skill: {
-      name: skill.frontmatter.name,
-      description: skill.frontmatter.description,
-      compatibility: skill.frontmatter.compatibility ?? null,
-      user_invocable: skill.frontmatter['user-invocable'] ?? true,
-      disable_model_invocation: skill.frontmatter['disable-model-invocation'] ?? false,
-    },
-    files: files.map((file) => ({
-      path: file.relativePath,
-      size: file.bytes.length,
-      sha256: file.sha256,
-    })),
-    note: 'This archive is a zip file with a .skill extension. Compatible agents can extract and install the included skill directory.',
-  };
-}
-
-export async function buildSkillPackage(skillDir, options = {}) {
-  const validation = await validateSkillDirectory(skillDir);
-  if (!validation.valid) {
-    throw new Error(`Cannot package invalid skill:\n- ${validation.errors.join('\n- ')}`);
-  }
-
-  const skill = await loadSkill(skillDir);
-  const discoveredFiles = await collectFiles(skillDir);
-  const files = [];
-  for (const file of discoveredFiles) {
-    if (file.relativePath.endsWith('.skill')) {
-      continue;
-    }
-    const bytes = toUint8Array(await readFile(file.absolutePath));
-    files.push({
-      ...file,
-      bytes,
-      sha256: sha256(bytes),
-    });
-  }
-
-  const manifest = createPackageManifest(skill, files, options);
-  const archiveEntries = {
-    [PACKAGE_MANIFEST_PATH]: strToU8(JSON.stringify(manifest, null, 2)),
-  };
-  for (const file of files) {
-    archiveEntries[file.relativePath] = file.bytes;
-  }
-
-  return {
-    manifest,
-    bytes: zipSync(archiveEntries, { level: 6 }),
-  };
-}
-
-export async function writeSkillPackage(skillDir, outputPath, options = {}) {
-  const result = await buildSkillPackage(skillDir, options);
-  await writeFile(outputPath, result.bytes);
-  return {
-    ...result,
-    outputPath: path.resolve(outputPath),
-  };
-}
-
-function parseArgs(argv) {
-  const args = {
-    skillDir: argv[2],
-    output: undefined,
-  };
-
-  for (let index = 3; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (token === '--output' && argv[index + 1]) {
-      args.output = argv[++index];
-    }
-  }
-
-  return args;
-}
-
+#!/usr/bin/env node
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { zipSync, strToU8 } from 'fflate';
+import { validateSkillDirectory } from './quick-validate.js';
+import { collectFiles, loadSkill } from './utils.js';
+
+const PACKAGE_MANIFEST_PATH = '.kodax-package.json';
+
+function toUint8Array(value) {
+  return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+
+function sha256(buffer) {
+  return createHash('sha256').update(buffer).digest('hex');
+}
+
+export function createPackageManifest(skill, files, options = {}) {
+  return {
+    format: 'kodax-skill-package',
+    version: 1,
+    created_at: options.createdAt ?? new Date().toISOString(),
+    entrypoint: 'SKILL.md',
+    skill: {
+      name: skill.frontmatter.name,
+      description: skill.frontmatter.description,
+      compatibility: skill.frontmatter.compatibility ?? null,
+      user_invocable: skill.frontmatter['user-invocable'] ?? true,
+      disable_model_invocation: skill.frontmatter['disable-model-invocation'] ?? false,
+    },
+    files: files.map((file) => ({
+      path: file.relativePath,
+      size: file.bytes.length,
+      sha256: file.sha256,
+    })),
+    note: 'This archive is a zip file with a .skill extension. Compatible agents can extract and install the included skill directory.',
+  };
+}
+
+export async function buildSkillPackage(skillDir, options = {}) {
+  const validation = await validateSkillDirectory(skillDir);
+  if (!validation.valid) {
+    throw new Error(`Cannot package invalid skill:\n- ${validation.errors.join('\n- ')}`);
+  }
+
+  const skill = await loadSkill(skillDir);
+  const discoveredFiles = await collectFiles(skillDir);
+  const files = [];
+  for (const file of discoveredFiles) {
+    if (file.relativePath.endsWith('.skill')) {
+      continue;
+    }
+    const bytes = toUint8Array(await readFile(file.absolutePath));
+    files.push({
+      ...file,
+      bytes,
+      sha256: sha256(bytes),
+    });
+  }
+
+  const manifest = createPackageManifest(skill, files, options);
+  const archiveEntries = {
+    [PACKAGE_MANIFEST_PATH]: strToU8(JSON.stringify(manifest, null, 2)),
+  };
+  for (const file of files) {
+    archiveEntries[file.relativePath] = file.bytes;
+  }
+
+  return {
+    manifest,
+    bytes: zipSync(archiveEntries, { level: 6 }),
+  };
+}
+
+export async function writeSkillPackage(skillDir, outputPath, options = {}) {
+  const result = await buildSkillPackage(skillDir, options);
+  await writeFile(outputPath, result.bytes);
+  return {
+    ...result,
+    outputPath: path.resolve(outputPath),
+  };
+}
+
+function parseArgs(argv) {
+  const args = {
+    skillDir: argv[2],
+    output: undefined,
+  };
+
+  for (let index = 3; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--output' && argv[index + 1]) {
+      args.output = argv[++index];
+    }
+  }
+
+  return args;
+}
+
 export async function main(argv = process.argv) {
   const args = parseArgs(argv);
-  if (!args.skillDir) {
-    console.error('Usage: node scripts/package-skill.js <skill-dir> [--output <file.skill>]');
-    process.exit(1);
-  }
-
-  const skill = await loadSkill(args.skillDir);
-  const outputPath = args.output ?? path.join(path.dirname(args.skillDir), `${skill.frontmatter.name}.skill`);
-  const result = await writeSkillPackage(args.skillDir, outputPath);
-  console.log(`Wrote ${result.outputPath}`);
-}
-
+  if (!args.skillDir) {
+    console.error('Usage: node scripts/package-skill.js <skill-dir> [--output <file.skill>]');
+    process.exit(1);
+  }
+
+  const skill = await loadSkill(args.skillDir);
+  const outputPath = args.output ?? path.join(path.dirname(args.skillDir), `${skill.frontmatter.name}.skill`);
+  const result = await writeSkillPackage(args.skillDir, outputPath);
+  console.log(`Wrote ${result.outputPath}`);
+}
+
 const isDirectRun = process.env.KODAX_MODULE_BUNDLE !== 'true'
   && process.argv[1]
-  && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-
-if (isDirectRun) {
-  main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  });
-}
+  && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+
+if (isDirectRun) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}