clckernel 1.2.6

package/test/adapters/base.test.js

@@ -0,0 +1,86 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('BaseAdapter', () => {
+  const BaseAdapter = require('../../src/adapters/base');
+
+  describe('constructor', () => {
+    it('stores name, projectType, and testRunner', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      assert.strictEqual(adapter.name, 'Test');
+      assert.strictEqual(adapter.projectType, 'frontend');
+      assert.strictEqual(adapter.testRunner, 'Jest');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns false by default', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      assert.strictEqual(adapter.detect('/tmp'), false);
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns empty array by default', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      assert.deepStrictEqual(adapter.getSafeguards(), []);
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns empty array by default', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      assert.deepStrictEqual(adapter.getTools(), []);
+    });
+  });
+
+  describe('provision()', () => {
+    it('creates docs/, sdds/, tools/ directories', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      const dir = createTmpProject({});
+      try {
+        adapter.provision(dir, {});
+
+        assert.ok(require('fs').existsSync(require('path').join(dir, 'docs', 'Journal')));
+        assert.ok(require('fs').existsSync(require('path').join(dir, 'docs', 'Architecture')));
+        assert.ok(require('fs').existsSync(require('path').join(dir, 'docs', 'Development')));
+        assert.ok(require('fs').existsSync(require('path').join(dir, 'sdds')));
+        assert.ok(require('fs').existsSync(require('path').join(dir, 'tools')));
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('writes .gitignore with sdds/* entry', () => {
+      const adapter = new BaseAdapter('Test', 'frontend', 'Jest');
+      const dir = createTmpProject({});
+      try {
+        adapter.provision(dir, {});
+
+        const gitignore = require('fs').readFileSync(
+          require('path').join(dir, '.gitignore'), 'utf-8'
+        );
+        assert.ok(gitignore.includes('sdds/*'));
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('writes AGENTS.md with adapter name and safeguards', () => {
+      const adapter = new BaseAdapter('TestStack', 'backend', 'Pytest');
+      const dir = createTmpProject({});
+      try {
+        adapter.provision(dir, {});
+
+        const agents = require('fs').readFileSync(
+          require('path').join(dir, 'AGENTS.md'), 'utf-8'
+        );
+        assert.ok(agents.includes('TestStack'));
+        assert.ok(agents.includes('BACKEND'));
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+});

package/test/adapters/django.test.js

@@ -0,0 +1,95 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('DjangoAdapter', () => {
+  const DjangoAdapter = require('../../src/adapters/django');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new DjangoAdapter();
+      assert.strictEqual(adapter.name, 'Django Framework');
+      assert.strictEqual(adapter.projectType, 'backend');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when manage.py exists', () => {
+      const dir = createTmpProject({ 'manage.py': '#!/usr/bin/env python' });
+      try {
+        const adapter = new DjangoAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when requirements.txt contains django', () => {
+      const dir = createTmpProject({ 'requirements.txt': 'django>=4.0\npsycopg2' });
+      try {
+        const adapter = new DjangoAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when pyproject.toml contains django', () => {
+      const dir = createTmpProject({
+        'pyproject.toml': '[project]\nname = "myapp"\ndependencies = ["django>=4.0"]',
+      });
+      try {
+        const adapter = new DjangoAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when no django indicators present', () => {
+      const dir = createTmpProject({
+        'requirements.txt': 'flask>=2.0',
+      });
+      try {
+        const adapter = new DjangoAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when directory is empty', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new DjangoAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new DjangoAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new DjangoAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});

package/test/adapters/fastapi.test.js

@@ -0,0 +1,88 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('FastApiAdapter', () => {
+  const FastApiAdapter = require('../../src/adapters/fastapi');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new FastApiAdapter();
+      assert.strictEqual(adapter.name, 'FastAPI Framework');
+      assert.strictEqual(adapter.projectType, 'backend');
+      assert.strictEqual(adapter.testRunner, 'Pytest');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when pyproject.toml contains fastapi', () => {
+      const dir = createTmpProject({
+        'pyproject.toml': '[project]\nname = "api"\ndependencies = ["fastapi>=0.100"]',
+      });
+      try {
+        const adapter = new FastApiAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when requirements.txt contains fastapi', () => {
+      const dir = createTmpProject({
+        'requirements.txt': 'fastapi>=0.100\nuvicorn',
+      });
+      try {
+        const adapter = new FastApiAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when no fastapi indicators present', () => {
+      const dir = createTmpProject({
+        'requirements.txt': 'flask>=2.0',
+      });
+      try {
+        const adapter = new FastApiAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when directory is empty', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new FastApiAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new FastApiAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new FastApiAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});

package/test/adapters/go.test.js

@@ -0,0 +1,81 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('GoAdapter', () => {
+  const GoAdapter = require('../../src/adapters/go');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new GoAdapter();
+      assert.strictEqual(adapter.name, 'Go (Golang)');
+      assert.strictEqual(adapter.projectType, 'backend');
+      assert.strictEqual(adapter.testRunner, 'go test');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when go.mod exists', () => {
+      const dir = createTmpProject({ 'go.mod': 'module example.com/myapp\ngo 1.21' });
+      try {
+        const adapter = new GoAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when go.mod does not exist', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new GoAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new GoAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+
+    it('all external tools have language=external and empty path', () => {
+      const adapter = new GoAdapter();
+      const tools = adapter.getTools();
+      const externalTools = tools.filter((t) => t.language === 'external');
+      for (const tool of externalTools) {
+        assert.strictEqual(tool.language, 'external');
+        assert.strictEqual(tool.path, '');
+      }
+    });
+
+    it('includes custom rules guard', () => {
+      const adapter = new GoAdapter();
+      const tools = adapter.getTools();
+      const customTool = tools.find((t) => t.name === 'check_custom');
+      assert.ok(customTool, 'check_custom tool should exist');
+      assert.strictEqual(customTool.language, 'js');
+      assert.strictEqual(customTool.path, 'check_custom.js');
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new GoAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});

package/test/adapters/laravel.test.js

@@ -0,0 +1,106 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('LaravelAdapter', () => {
+  const LaravelAdapter = require('../../src/adapters/laravel');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new LaravelAdapter();
+      assert.strictEqual(adapter.name, 'PHP / Laravel');
+      assert.strictEqual(adapter.projectType, 'backend');
+      assert.strictEqual(adapter.testRunner, 'Pest / PHPUnit');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when both composer.json and artisan exist', () => {
+      const dir = createTmpProject({
+        'composer.json': JSON.stringify({ require: { 'laravel/framework': '^10.0' } }),
+        'artisan': '#!/usr/bin/env php',
+      });
+      try {
+        const adapter = new LaravelAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when only composer.json exists', () => {
+      const dir = createTmpProject({
+        'composer.json': JSON.stringify({ require: {} }),
+      });
+      try {
+        const adapter = new LaravelAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when only artisan exists', () => {
+      const dir = createTmpProject({ 'artisan': '#!/usr/bin/env php' });
+      try {
+        const adapter = new LaravelAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when directory is empty', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new LaravelAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new LaravelAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+
+    it('all external tools have language=external and empty path', () => {
+      const adapter = new LaravelAdapter();
+      const tools = adapter.getTools();
+      const externalTools = tools.filter((t) => t.language === 'external');
+      for (const tool of externalTools) {
+        assert.strictEqual(tool.language, 'external');
+        assert.strictEqual(tool.path, '');
+      }
+    });
+
+    it('includes custom rules guard', () => {
+      const adapter = new LaravelAdapter();
+      const tools = adapter.getTools();
+      const customTool = tools.find((t) => t.name === 'check_custom');
+      assert.ok(customTool, 'check_custom tool should exist');
+      assert.strictEqual(customTool.language, 'python');
+      assert.strictEqual(customTool.path, 'check_custom.py');
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new LaravelAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});

package/test/adapters/nextjs.test.js

@@ -0,0 +1,113 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('NextjsAdapter', () => {
+  const NextjsAdapter = require('../../src/adapters/nextjs');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new NextjsAdapter();
+      assert.strictEqual(adapter.name, 'Next.js (App Router)');
+      assert.strictEqual(adapter.projectType, 'frontend');
+      assert.strictEqual(adapter.testRunner, 'Vitest / Jest');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when package.json has next dependency', () => {
+      const dir = createTmpProject({
+        'package.json': JSON.stringify({ dependencies: { next: '14.0.0' } }),
+      });
+      try {
+        const adapter = new NextjsAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when next is in devDependencies', () => {
+      const dir = createTmpProject({
+        'package.json': JSON.stringify({ devDependencies: { next: '14.0.0' } }),
+      });
+      try {
+        const adapter = new NextjsAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when package.json has no next dependency', () => {
+      const dir = createTmpProject({
+        'package.json': JSON.stringify({ dependencies: { react: '18.0.0' } }),
+      });
+      try {
+        const adapter = new NextjsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when no package.json exists', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new NextjsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when package.json is malformed JSON', () => {
+      const dir = createTmpProject({
+        'package.json': '{invalid json',
+      });
+      try {
+        const adapter = new NextjsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new NextjsAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name, 'tool must have name');
+        assert.ok(tool.language, 'tool must have language');
+        assert.ok(typeof tool.command === 'string', 'tool must have command string');
+        assert.ok(tool.description, 'tool must have description');
+      }
+    });
+
+    it('external tools have language=external and empty path', () => {
+      const adapter = new NextjsAdapter();
+      const tools = adapter.getTools();
+      const external = tools.filter((t) => t.language === 'external');
+      assert.ok(external.length > 0, 'should have external tools');
+      for (const tool of external) {
+        assert.strictEqual(tool.path, '');
+      }
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new NextjsAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5, 'should have at least 5 safeguards');
+      for (const g of guards) {
+        assert.strictEqual(typeof g, 'string');
+      }
+    });
+  });
+});

package/test/adapters/rails.test.js

@@ -0,0 +1,108 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('RailsAdapter', () => {
+  const RailsAdapter = require('../../src/adapters/rails');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new RailsAdapter();
+      assert.strictEqual(adapter.name, 'Ruby on Rails');
+      assert.strictEqual(adapter.projectType, 'backend');
+      assert.strictEqual(adapter.testRunner, 'RSpec / Minitest');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when Gemfile and config/routes.rb exist', () => {
+      const dir = createTmpProject({
+        'Gemfile': "source 'https://rubygems.org'\ngem 'rails', '~> 7.0'",
+        'config/routes.rb': 'Rails.application.routes.draw do end',
+      });
+      try {
+        const adapter = new RailsAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when only Gemfile exists (no routes.rb)', () => {
+      const dir = createTmpProject({
+        'Gemfile': "source 'https://rubygems.org'",
+      });
+      try {
+        const adapter = new RailsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when only routes.rb exists (no Gemfile)', () => {
+      const dir = createTmpProject({
+        'config/routes.rb': 'Rails.application.routes.draw do end',
+      });
+      try {
+        const adapter = new RailsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when directory is empty', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new RailsAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new RailsAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+
+    it('all external tools have language=external and empty path', () => {
+      const adapter = new RailsAdapter();
+      const tools = adapter.getTools();
+      const externalTools = tools.filter((t) => t.language === 'external');
+      for (const tool of externalTools) {
+        assert.strictEqual(tool.language, 'external');
+        assert.strictEqual(tool.path, '');
+      }
+    });
+
+    it('includes custom rules guard', () => {
+      const adapter = new RailsAdapter();
+      const tools = adapter.getTools();
+      const customTool = tools.find((t) => t.name === 'check_custom');
+      assert.ok(customTool, 'check_custom tool should exist');
+      assert.strictEqual(customTool.language, 'js');
+      assert.strictEqual(customTool.path, 'check_custom.js');
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new RailsAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});