thoth-agents 0.3.5 → 0.3.6

package/skills/thoth-init/scripts/init.mjs

@@ -3,10 +3,10 @@
 import {
   cpSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readdirSync,
   readFileSync,
-  statSync,
   writeFileSync,
 } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
@@ -15,12 +15,13 @@ import { fileURLToPath } from 'node:url';
 const SCRIPT_PATH = fileURLToPath(import.meta.url);
 const SKILL_ROOT = dirname(dirname(SCRIPT_PATH));
 const BUNDLE_ROOT = dirname(SKILL_ROOT);
-const OWNED_SKILL_NAMES = [
-  'thoth-init',
-  'thoth-sdd',
-  'thoth-constitution',
-  'thoth-archive',
-  'plan-reviewer',
+const OPEN_SPEC_DIRECTORIES = [
+  'openspec',
+  join('openspec', 'changes'),
+  join('openspec', 'changes', 'archive'),
+  join('openspec', 'specs'),
+  join('openspec', 'memory'),
+  join('openspec', 'templates'),
 ];
 
 function parseArgs(argv) {
@@ -29,110 +30,193 @@ function parseArgs(argv) {
     const argument = argv[index];
     if (argument === '--json') options.json = true;
     else if (argument === '--project') options.project = argv[++index];
-    else if (argument === '--harness') options.harness = argv[++index];
     else throw new Error(`Unknown argument: ${argument}`);
   }
   if (!options.project) throw new Error('--project is required');
-  if (!['opencode', 'codex', 'claude'].includes(options.harness)) {
-    throw new Error('--harness must be opencode, codex, or claude');
-  }
   return options;
 }
 
-function copyMissing(source, target, report) {
-  if (!existsSync(source)) return;
-  const sourceStat = statSync(source);
-  if (sourceStat.isDirectory()) {
-    mkdirSync(target, { recursive: true });
-    for (const entry of readdirSync(source)) {
-      copyMissing(join(source, entry), join(target, entry), report);
+function assertDirectory(path, label) {
+  if (!existsSync(path)) return;
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${path}`);
+  }
+}
+
+function assertRegularFile(path, label) {
+  if (!existsSync(path)) return;
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    throw new Error(`${label} must be a regular file: ${path}`);
+  }
+}
+
+function collectFiles(sourceRoot, targetRoot) {
+  if (!existsSync(sourceRoot)) {
+    throw new Error(`Bundled SDD template directory is missing: ${sourceRoot}`);
+  }
+  assertDirectory(sourceRoot, 'Bundled template directory');
+  const entries = [];
+
+  function visit(source, target) {
+    for (const entry of readdirSync(source, { withFileTypes: true })) {
+      const sourcePath = join(source, entry.name);
+      const targetPath = join(target, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(
+          `Bundled templates cannot contain symlinks: ${sourcePath}`,
+        );
+      }
+      if (entry.isDirectory()) {
+        entries.push({ kind: 'directory', target: targetPath });
+        visit(sourcePath, targetPath);
+      } else if (entry.isFile()) {
+        entries.push({ kind: 'file', source: sourcePath, target: targetPath });
+      } else {
+        throw new Error(`Unsupported bundled template entry: ${sourcePath}`);
+      }
     }
-    return;
   }
+
+  visit(sourceRoot, targetRoot);
+  return entries;
+}
+
+function preflight(project) {
+  assertDirectory(project, 'Project root');
+  if (!existsSync(project)) {
+    throw new Error(
+      `--project must reference an existing project directory: ${project}`,
+    );
+  }
+
+  const constitutionSource = join(
+    BUNDLE_ROOT,
+    'thoth-constitution',
+    'templates',
+    'constitution.md',
+  );
+  assertRegularFile(constitutionSource, 'Bundled constitution template');
+  if (!existsSync(constitutionSource)) {
+    throw new Error(
+      `Bundled constitution template is missing: ${constitutionSource}`,
+    );
+  }
+
+  const templates = collectFiles(
+    join(BUNDLE_ROOT, 'thoth-sdd', 'templates'),
+    join(project, 'openspec', 'templates'),
+  );
+  for (const directory of OPEN_SPEC_DIRECTORIES) {
+    assertDirectory(join(project, directory), 'OpenSpec path');
+  }
+  for (const entry of templates) {
+    if (entry.kind === 'directory') {
+      assertDirectory(entry.target, 'OpenSpec template path');
+    } else {
+      assertRegularFile(entry.target, 'OpenSpec template path');
+    }
+  }
+
+  const constitutionTarget = join(
+    project,
+    'openspec',
+    'memory',
+    'constitution.md',
+  );
+  const manifestTarget = join(project, 'openspec', '.thoth-agents.json');
+  assertRegularFile(constitutionTarget, 'OpenSpec constitution path');
+  assertRegularFile(manifestTarget, 'OpenSpec manifest path');
+
+  return {
+    constitutionSource,
+    constitutionTarget,
+    manifestTarget,
+    templates,
+  };
+}
+
+function createDirectory(target, report) {
+  if (existsSync(target)) return;
+  mkdirSync(target);
+  report.created.push(target);
+}
+
+function copyPreservingExisting(source, target, report) {
   if (existsSync(target)) {
-    report.skipped.push(target);
+    report.preserved.push(target);
     return;
   }
-  mkdirSync(dirname(target), { recursive: true });
   cpSync(source, target, { errorOnExist: true });
   report.created.push(target);
 }
 
-function writeMissing(target, content, report) {
+function writePreservingExisting(target, content, report) {
   if (existsSync(target)) {
-    report.skipped.push(target);
+    report.preserved.push(target);
     return;
   }
-  mkdirSync(dirname(target), { recursive: true });
   writeFileSync(target, content);
   report.created.push(target);
 }
 
-function installConstitution(project, report) {
-  const target = join(project, 'openspec', 'memory', 'constitution.md');
-  const template = join(
-    BUNDLE_ROOT,
-    'thoth-constitution',
-    'templates',
-    'constitution.md',
-  );
-  if (!existsSync(template)) return;
-  const today = new Date().toISOString().slice(0, 10);
-  writeMissing(
-    target,
-    readFileSync(template, 'utf8').replaceAll('YYYY-MM-DD', today),
-    report,
-  );
+function synchronizeManagedFile(target, content, report) {
+  if (!existsSync(target)) {
+    writeFileSync(target, content);
+    report.created.push(target);
+    return;
+  }
+  if (readFileSync(target, 'utf8') === content) {
+    report.preserved.push(target);
+    return;
+  }
+  writeFileSync(target, content);
+  report.managed.push(target);
 }
 
-function installGovernance(project, report) {
-  installConstitution(project, report);
-  const templatesRoot = join(BUNDLE_ROOT, 'thoth-sdd', 'templates');
-  if (existsSync(templatesRoot)) {
-    for (const entry of readdirSync(templatesRoot)) {
-      copyMissing(
-        join(templatesRoot, entry),
-        join(project, 'openspec', 'templates', entry),
-        report,
-      );
-    }
+function synchronizeOpenSpec(project, assets, report) {
+  for (const directory of OPEN_SPEC_DIRECTORIES) {
+    createDirectory(join(project, directory), report);
   }
-  writeMissing(
-    join(project, 'openspec', '.thoth-agents.json'),
+  for (const entry of assets.templates) {
+    if (entry.kind === 'directory') createDirectory(entry.target, report);
+    else copyPreservingExisting(entry.source, entry.target, report);
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  writePreservingExisting(
+    assets.constitutionTarget,
+    readFileSync(assets.constitutionSource, 'utf8').replaceAll(
+      'YYYY-MM-DD',
+      today,
+    ),
+    report,
+  );
+  synchronizeManagedFile(
+    assets.manifestTarget,
     `${JSON.stringify({ version: 1, initializedBy: 'thoth-agents' }, null, 2)}\n`,
     report,
   );
 }
 
-function installOpenCode(project, report) {
-  for (const skillName of OWNED_SKILL_NAMES) {
-    copyMissing(
-      join(BUNDLE_ROOT, skillName),
-      join(project, '.agents', 'skills', skillName),
-      report,
-    );
-  }
-}
-
 try {
   const options = parseArgs(process.argv.slice(2));
   const project = resolve(options.project);
-  mkdirSync(project, { recursive: true });
+  const assets = preflight(project);
   const report = {
     status: 'ready',
-    harness: options.harness,
     project,
     created: [],
     managed: [],
-    skipped: [],
+    preserved: [],
   };
 
-  installGovernance(project, report);
-  if (options.harness === 'opencode') installOpenCode(project, report);
+  synchronizeOpenSpec(project, assets, report);
 
   const output = options.json
     ? JSON.stringify(report)
-    : `thoth-agents initialized ${project} for ${options.harness}`;
+    : `thoth-agents synchronized OpenSpec governance in ${project}`;
   process.stdout.write(`${output}\n`);
 } catch (error) {
   process.stderr.write(