@flancer32/skill-adsm-ctx 0.2.1 → 0.4.0

package/src/Bootstrap.mjs

@@ -1,108 +0,0 @@
-// @ts-check
-
-/**
- * @namespace Fl32_Skill_Adsm_Ctx_Bootstrap
- * @description TeqFW root CLI application component for ADSM context lifecycle operations.
- */
-
-export default class Bootstrap {
-  /**
-   * @param {object} deps
-   * @param {Fl32_Skill_Adsm_Ctx_Bootstrap_Cli} deps.cli
-   * @param {Fl32_Skill_Adsm_Ctx_Design_Service} deps.design
-   * @param {Fl32_Skill_Adsm_Ctx_Init_Service} deps.init
-   * @param {Fl32_Skill_Adsm_Ctx_Skill_Installer} deps.installer
-   * @param {Fl32_Skill_Adsm_Ctx_Upgrade_Service} deps.upgrade
-   * @param {Fl32_Skill_Adsm_Ctx_Validate_Service} deps.validate
-   */
-  constructor({cli, design, init, installer, upgrade, validate}) {
-    let stopping = false;
-
-    /**
-     * Runs the CLI application once.
-     *
-     * @param {object} params
-     * @param {string[]} params.cliArgs
-     * @param {string} params.projectRoot
-     * @returns {Promise<number>}
-     */
-    this.run = async ({cliArgs = [], projectRoot}) => {
-      const parsed = cli.parse({cliArgs, projectRoot});
-
-      if (parsed.helpRequested) {
-        process.stderr.write(`${parsed.usage}\n`);
-        return 0;
-      }
-
-      if (parsed.errors.length > 0) {
-        process.stderr.write(`${parsed.errors.join("\n")}\n`);
-        process.stderr.write(`${parsed.usage}\n`);
-        return 2;
-      }
-
-      if (parsed.command === "init") {
-        const result = await init.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${formatInitReport(result)}\n`);
-        return 0;
-      }
-
-      if (parsed.command === "design") {
-        process.stdout.write(`${await design.execute({targetPath: parsed.targetPath})}\n`);
-        return 0;
-      }
-
-      if (parsed.command === "validate") {
-        const result = await validate.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${validate.format({result})}\n`);
-        return result.ok ? 0 : 1;
-      }
-
-      if (parsed.command === "upgrade") {
-        const result = await upgrade.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${result.message}\n`);
-        return result.ok ? 0 : 1;
-      }
-
-      if (parsed.command === "install-skill") {
-        const targetDir = await installer.execute({targetRoot: parsed.targetPath});
-        process.stdout.write(`Installed skill payload to ${targetDir}\n`);
-        return 0;
-      }
-
-      process.stderr.write(`${parsed.usage}\n`);
-      return 2;
-    };
-
-    /**
-     * Stops the application.
-     *
-     * @returns {Promise<void>}
-     */
-    this.stop = async () => {
-      if (stopping) return;
-      stopping = true;
-    };
-  }
-}
-
-/**
- * @param {{ctxRoot: string, created: string[], skipped: string[]}} result
- * @returns {string}
- */
-function formatInitReport(result) {
-  const lines = [
-    `Initialized ADSM context in ${result.ctxRoot}`,
-    ...result.created.map((entry) => `Created: ${entry}`),
-    ...result.skipped.map((entry) => `Skipped: ${entry}`),
-  ];
-  return lines.join("\n");
-}
-
-export const __deps__ = Object.freeze({
-  cli: "Fl32_Skill_Adsm_Ctx_Bootstrap_Cli$",
-  design: "Fl32_Skill_Adsm_Ctx_Design_Service$",
-  init: "Fl32_Skill_Adsm_Ctx_Init_Service$",
-  installer: "Fl32_Skill_Adsm_Ctx_Skill_Installer$",
-  upgrade: "Fl32_Skill_Adsm_Ctx_Upgrade_Service$",
-  validate: "Fl32_Skill_Adsm_Ctx_Validate_Service$",
-});

package/test/integration/.gitkeep

@@ -1 +0,0 @@
-

package/test/integration/cli-help.test.mjs

@@ -1,15 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli help works', () => {
-  const result = spawnSync('node', [cliPath, '--help'], {encoding: 'utf8'});
-  assert.equal(result.status, 0);
-  assert.match(result.stderr, /Usage: adsm-ctx/);
-});

package/test/integration/cli-init-validate.test.mjs

@@ -1,223 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli init creates files in current working directory by default', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-init-'));
-  const result = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-  try {
-    assert.equal(result.status, 0, result.stderr);
-    assert.ok(fs.existsSync(path.join(sandboxRoot, 'ctx', 'adsm.json')));
-    const filesystemDoc = fs.readFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'filesystem.md'), 'utf8');
-    const productDomainDoc = fs.readFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.md'), 'utf8');
-    assert.match(filesystemDoc, /This starter is not a completed repository map/);
-    assert.doesNotMatch(filesystemDoc, /npm package repository/);
-    assert.doesNotMatch(filesystemDoc, /node_modules/);
-    assert.match(productDomainDoc, /- Changed: `\d{8}`/);
-    assert.doesNotMatch(productDomainDoc, /- Changed: `YYYYMMDD`/);
-    assert.match(result.stdout, /Initialized ADSM context in /);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate succeeds after init in a clean project', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-validate-ok-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    const validateResult = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-    assert.equal(initResult.status, 0, initResult.stderr);
-    assert.equal(validateResult.status, 0, validateResult.stderr);
-    assert.match(validateResult.stdout, /ADSM context validation passed/);
-    assert.match(validateResult.stdout, /Errors: 0/);
-    assert.match(validateResult.stdout, /Warnings: 0/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli init does not overwrite existing metadata and validate succeeds after init', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-safe-init-'));
-
-  try {
-    fs.mkdirSync(path.join(sandboxRoot, 'ctx'), {recursive: true});
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'adsm.json'), '{"schema":"custom","version":"9.9.9"}\n');
-
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    const validateResult = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-    assert.equal(initResult.status, 0, initResult.stderr);
-    assert.match(fs.readFileSync(path.join(sandboxRoot, 'ctx', 'adsm.json'), 'utf8'), /"schema":"custom"/);
-    assert.equal(validateResult.status, 1);
-    assert.match(validateResult.stdout, /Unexpected schema: custom/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports missing context in empty directory', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-empty-'));
-
-  try {
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing: ctx/);
-    assert.match(result.stdout, /Missing ctx\/adsm\.json/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports invalid skin structure and reference', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-invalid-skin-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.skin.en.md'), [
-      '# Product Domain Skin',
-      '',
-      '- Path: `ctx/docs/product/domain.skin.en.md`',
-      '- Changed: `20260708`',
-      '',
-      '## Purpose',
-      '',
-      'Human-facing control.',
-      '',
-      '## Scope',
-      '',
-      'Includes:',
-      '',
-      '- domain identity.',
-      '',
-      '## Invariants',
-      '',
-      '- Keep the domain stable.',
-      '- invariant 1.',
-      '- invariant 2.',
-      '- invariant 3.',
-      '- invariant 4.',
-      '- invariant 5.',
-      '- invariant 6.',
-      '- invariant 7.',
-      '- invariant 8.',
-      '- invariant 9.',
-      '- invariant 10.',
-      '- invariant 11.',
-      '- invariant 12.',
-      '',
-      '## Agent Document',
-      '',
-      '`other.md`',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing skin section "Mental Model": ctx\/docs\/product\/domain\.skin\.en\.md/);
-    assert.match(result.stdout, /Missing Excludes: block in Scope: ctx\/docs\/product\/domain\.skin\.en\.md/);
-    assert.match(result.stdout, /Skin agent document mismatch: ctx\/docs\/product\/domain\.skin\.en\.md references ctx\/docs\/product\/other\.md but expected ctx\/docs\/product\/domain\.md/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports broken local markdown links as errors', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-broken-link-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'overview.md'), [
-      '# Product Overview',
-      '',
-      '- Path: `ctx/docs/product/overview.md`',
-      '- Changed: `20260708`',
-      '',
-      'See [domain](./missing.md).',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing linked document: \.\/missing\.md resolves to ctx\/docs\/product\/missing\.md/);
-    assert.match(result.stdout, /Errors: [1-9]/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate succeeds with warnings only', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-warning-only-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.skin.en.md'), [
-      '# Product Domain Skin',
-      '',
-      '- Path: `ctx/docs/product/domain.skin.en.md`',
-      '- Changed: `20260708`',
-      '',
-      '## Purpose',
-      '',
-      'See [domain](./domain.md#purpose) while keeping the human-facing summary compact.',
-      '',
-      '## Mental Model',
-      '',
-      'This is the human semantic frame.',
-      '',
-      '## Scope',
-      '',
-      'Includes:',
-      '',
-      '- domain identity.',
-      '',
-      'Excludes:',
-      '',
-      '- operational overload.',
-      '',
-      '## Invariants',
-      '',
-      '- Keep the domain stable.',
-      '- invariant 1.',
-      '- invariant 2.',
-      '- invariant 3.',
-      '- invariant 4.',
-      '- invariant 5.',
-      '- invariant 6.',
-      '- invariant 7.',
-      '- invariant 8.',
-      '- invariant 9.',
-      '- invariant 10.',
-      '- invariant 11.',
-      '- invariant 12.',
-      '',
-      '## Agent Document',
-      '',
-      '`domain.md`',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 0, result.stderr);
-    assert.match(result.stdout, /passed with warnings/i);
-    assert.match(result.stdout, /Errors: 0/);
-    assert.match(result.stdout, /Warnings: [1-9]/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});

package/test/integration/cli-install-skill.test.mjs

@@ -1,41 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli install-skill installs current payload and replaces stale target content', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-install-skill-'));
-  const skillDir = path.join(sandboxRoot, 'adsm-ctx');
-  const staleFile = path.join(skillDir, 'stale.txt');
-  const installedSkill = path.join(skillDir, 'SKILL.md');
-  const installedReference = path.join(skillDir, 'references', 'context-lifecycle.md');
-  const installedTemplate = path.join(skillDir, 'templates', 'ctx', 'docs', 'architecture', 'overview.md');
-
-  try {
-    fs.mkdirSync(skillDir, {recursive: true});
-    fs.writeFileSync(staleFile, 'obsolete payload\n');
-    fs.writeFileSync(installedSkill, 'outdated skill\n');
-
-    const result = spawnSync('node', [cliPath, 'install-skill', sandboxRoot], {encoding: 'utf8'});
-
-    assert.equal(result.status, 0, result.stderr);
-    assert.match(result.stdout, new RegExp(`Installed skill payload to ${escapeRegExp(skillDir)}`));
-    assert.ok(fs.existsSync(installedSkill));
-    assert.ok(fs.existsSync(installedReference));
-    assert.ok(fs.existsSync(installedTemplate));
-    assert.match(fs.readFileSync(installedSkill, 'utf8'), /name: adsm-ctx/);
-    assert.equal(fs.existsSync(staleFile), false);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/test/unit/Bootstrap/Cli.test.mjs

@@ -1,23 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Cli from '../../../src/Bootstrap/Cli.mjs';
-
-test('Cli uses project root as default target path', () => {
-  const cli = new Cli({pathService: {resolve: (value) => `/abs/${value}`}});
-  const result = cli.parse({cliArgs: ['init'], projectRoot: '/cwd'});
-  assert.equal(result.targetPath, '/cwd');
-  assert.equal(result.command, 'init');
-});
-
-test('Cli resolves explicit target path', () => {
-  const cli = new Cli({pathService: {resolve: (value) => `/abs/${value}`}});
-  const result = cli.parse({cliArgs: ['validate', 'demo'], projectRoot: '/cwd'});
-  assert.equal(result.targetPath, '/abs/demo');
-});
-
-test('Cli requires target root for install-skill', () => {
-  const cli = new Cli({pathService: {resolve: (value) => value}});
-  const result = cli.parse({cliArgs: ['install-skill'], projectRoot: '/cwd'});
-  assert.match(result.errors.join('\n'), /install-skill <skills-root>/);
-});

package/test/unit/Bootstrap.test.mjs

@@ -1,53 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Bootstrap from '../../src/Bootstrap.mjs';
-
-test('Bootstrap routes init command and reports created and skipped entries', async () => {
-  const writes = {stdout: [], stderr: []};
-  const stdoutWrite = process.stdout.write;
-  const stderrWrite = process.stderr.write;
-  process.stdout.write = (chunk) => { writes.stdout.push(String(chunk)); return true; };
-  process.stderr.write = (chunk) => { writes.stderr.push(String(chunk)); return true; };
-
-  try {
-    const app = new Bootstrap({
-      cli: {parse: () => ({command: 'init', errors: [], helpRequested: false, targetPath: '/project', usage: 'usage'})},
-      design: {execute: async () => ''},
-      init: {execute: async () => ({ctxRoot: '/project/ctx', created: ['ctx'], skipped: ['ctx/adsm.json']})},
-      installer: {execute: async () => ''},
-      upgrade: {execute: async () => ({ok: true, message: ''})},
-      validate: {execute: async () => ({ok: true}), format: () => ''},
-    });
-
-    const code = await app.run({cliArgs: ['init'], projectRoot: '/project'});
-    assert.equal(code, 0);
-    assert.match(writes.stdout.join(''), /Created: ctx/);
-    assert.match(writes.stdout.join(''), /Skipped: ctx\/adsm\.json/);
-  } finally {
-    process.stdout.write = stdoutWrite;
-    process.stderr.write = stderrWrite;
-  }
-});
-
-test('Bootstrap prints help and exits with zero', async () => {
-  const writes = {stdout: [], stderr: []};
-  const stderrWrite = process.stderr.write;
-  process.stderr.write = (chunk) => { writes.stderr.push(String(chunk)); return true; };
-
-  try {
-    const app = new Bootstrap({
-      cli: {parse: () => ({errors: [], helpRequested: true, usage: 'usage'})},
-      design: {execute: async () => ''},
-      init: {execute: async () => ({})},
-      installer: {execute: async () => ''},
-      upgrade: {execute: async () => ({ok: true, message: ''})},
-      validate: {execute: async () => ({ok: true}), format: () => ''},
-    });
-    const code = await app.run({cliArgs: ['--help'], projectRoot: '/project'});
-    assert.equal(code, 0);
-    assert.equal(writes.stderr.join(''), 'usage\n');
-  } finally {
-    process.stderr.write = stderrWrite;
-  }
-});

package/test/unit/Design/Service.test.mjs

@@ -1,11 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Service from '../../../src/Design/Service.mjs';
-
-test('Design service references questionnaire and orchestration', async () => {
-  const service = new Service();
-  const result = await service.execute({targetPath: '/project'});
-  assert.match(result, /design-questionnaire\.md/);
-  assert.match(result, /specialized ADSM skills/);
-});

package/test/unit/Init/Service.test.mjs

@@ -1,51 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Service from '../../../src/Init/Service.mjs';
-
-test('Init service creates metadata only when missing', async () => {
-  const writes = [];
-  const fs = {
-    existing: new Set(),
-    existsSync(path) { return this.existing.has(path); },
-    mkdirSync(path) { this.existing.add(path); },
-    writeFileSync(path, content) { this.existing.add(path); writes.push({path, content}); },
-  };
-  const copyDirectory = {
-    copyMissing: ({created}) => created.push('ctx'),
-  };
-  const service = new Service({
-    copyDirectory,
-    fs,
-    metadata: {create: () => ({schema: 'adsm-context', version: '0.1.0'})},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => value},
-    url: {fileURLToPath: () => '/templates/ctx'},
-  });
-
-  const result = await service.execute({targetPath: '/project'});
-  assert.equal(result.projectRoot, '/project');
-  assert.ok(result.created.includes('ctx'));
-  assert.ok(result.created.includes('AGENTS.md'));
-  assert.ok(result.created.includes('ctx/adsm.json'));
-  assert.match(writes.find((item) => item.path === '/project/ctx/adsm.json').content, /"version": "0\.1\.0"/);
-});
-
-test('Init service skips existing root agents and metadata', async () => {
-  const fs = {
-    existing: new Set(['/project/AGENTS.md', '/project/ctx/adsm.json']),
-    existsSync(path) { return this.existing.has(path); },
-    mkdirSync() {},
-    writeFileSync() { throw new Error('unexpected write'); },
-  };
-  const service = new Service({
-    copyDirectory: {copyMissing() {}},
-    fs,
-    metadata: {create: () => ({schema: 'adsm-context', version: '0.1.0'})},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => value},
-    url: {fileURLToPath: () => '/templates/ctx'},
-  });
-
-  const result = await service.execute({targetPath: '/project'});
-  assert.ok(result.skipped.includes('AGENTS.md'));
-  assert.ok(result.skipped.includes('ctx/adsm.json'));
-});

package/test/unit/Shared/Constants.test.mjs

@@ -1,21 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Constants from '../../../src/Shared/Constants.mjs';
-
-test('Constants publish required baseline markers', () => {
-  const constants = new Constants();
-  assert.equal(constants.CONTEXT_SCHEMA, 'adsm-context');
-  assert.equal(constants.CONTEXT_VERSION, '0.1.0');
-  assert.equal(constants.SKIN_WORD_WARN, 160);
-  assert.equal(constants.SKIN_WORD_ERROR, 240);
-  assert.equal(constants.SKIN_LIST_WARN, 12);
-  assert.equal(constants.SKIN_LIST_ERROR, 20);
-  assert.equal(constants.DOC_LEVEL_MAX_DIRECTORIES, 9);
-  assert.equal(constants.DOC_LEVEL_MAX_FILES, 9);
-  assert.ok(constants.REQUIRED_PATHS.includes('ctx/adsm.json'));
-  assert.deepEqual(constants.DOC_LEVELS, ['product', 'architecture', 'environment', 'code']);
-  assert.ok(constants.REQUIRED_PATHS.includes('ctx/docs/architecture'));
-  assert.equal(constants.REQUIRED_PATHS.includes('ctx/docs/product/overview.md'), false);
-  assert.equal(constants.REQUIRED_PATHS.includes('ctx/docs/filesystem.md'), false);
-});

package/test/unit/Shared/CopyDirectory.test.mjs

@@ -1,31 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import CopyDirectory from '../../../src/Shared/CopyDirectory.mjs';
-
-test('CopyDirectory copies only missing files', () => {
-  const copied = [];
-  const fs = {
-    existing: new Set(['/target', '/target/exists.txt']),
-    existsSync(path) { return this.existing.has(path); },
-    mkdirSync(path) { this.existing.add(path); },
-    readdirSync(path) {
-      if (path === '/source') {
-        return [
-          {name: 'exists.txt', isDirectory: () => false},
-          {name: 'missing.txt', isDirectory: () => false},
-        ];
-      }
-      return [];
-    },
-    copyFileSync(source, target) { copied.push({source, target}); this.existing.add(target); },
-  };
-  const service = new CopyDirectory({fs, pathService: {join: (...parts) => parts.join('/')}});
-  const created = [];
-  const skipped = [];
-  service.copyMissing({created, skipped, pathPrefix: 'ctx', sourcePath: '/source', targetPath: '/target'});
-
-  assert.deepEqual(copied, [{source: '/source/missing.txt', target: '/target/missing.txt'}]);
-  assert.ok(created.includes('ctx/missing.txt'));
-  assert.ok(skipped.includes('ctx/exists.txt'));
-});

package/test/unit/Shared/Metadata.test.mjs

@@ -1,9 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Metadata from '../../../src/Shared/Metadata.mjs';
-
-test('Metadata creates baseline payload without hardcoded date field', () => {
-  const metadata = new Metadata({constants: {CONTEXT_SCHEMA: 'adsm-context', CONTEXT_VERSION: '0.1.0'}});
-  assert.deepEqual(metadata.create(), {schema: 'adsm-context', version: '0.1.0'});
-});

package/test/unit/Shared/Path.test.mjs

@@ -1,11 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import PathService from '../../../src/Shared/Path.mjs';
-
-test('Path service delegates resolve and join', () => {
-  const path = {resolve: (value) => `/root/${value}`, join: (...parts) => parts.join('/')};
-  const service = new PathService({path});
-  assert.equal(service.resolve('demo'), '/root/demo');
-  assert.equal(service.join('a', 'b'), 'a/b');
-});

package/test/unit/Skill/Installer.test.mjs

@@ -1,20 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Installer from '../../../src/Skill/Installer.mjs';
-
-test('Installer removes target and copies skill payload', async () => {
-  const removed = [];
-  const copied = [];
-  const installer = new Installer({
-    copyDirectory: {execute: (params) => copied.push(params)},
-    fs: {rmSync: (target, options) => removed.push({target, options})},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => `/abs/${value}`},
-    url: {fileURLToPath: () => '/repo/skill'},
-  });
-
-  const result = await installer.execute({targetRoot: 'skills'});
-  assert.equal(result, '/abs/skills/adsm-ctx');
-  assert.deepEqual(removed[0], {target: '/abs/skills/adsm-ctx', options: {recursive: true, force: true}});
-  assert.deepEqual(copied[0], {sourcePath: '/repo/skill', targetPath: '/abs/skills/adsm-ctx'});
-});

package/test/unit/Upgrade/Service.test.mjs

@@ -1,13 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Service from '../../../src/Upgrade/Service.mjs';
-
-test('Upgrade service reports missing metadata', async () => {
-  const service = new Service({
-    fs: {existsSync: () => false},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => value},
-  });
-  const result = await service.execute({targetPath: '/project'});
-  assert.equal(result.ok, false);
-});