@kal-elsam/kairo-runtime 0.1.0

package/src/template-installer.js

@@ -0,0 +1,72 @@
+import { mkdir, symlink, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { COMPATIBILITY_LINKS, adapterForPath, listTemplateFiles, pathExists, renderFileContent } from "./harness-files.js";
+import { hashBuffer } from "./hash.js";
+import { createManifest, readManifest, writeManifest } from "./manifest.js";
+
+export async function installHarness({ project, packageRoot, mode, adapters, packageName, cliVersion, force = false, dryRun = false }) {
+  const templateFiles = await listTemplateFiles(packageRoot, mode, { adapters });
+  const normalizedAdapters = adapters == null ? null : [...adapters].sort();
+  const result = { mode, adapters: normalizedAdapters, created: [], skipped: [], updated: [] };
+  const manifestFiles = {};
+
+  for (const { relativePath, sourcePath } of templateFiles) {
+    const destinationPath = resolve(project.root, relativePath);
+    const exists = await pathExists(destinationPath);
+
+    if (exists && !force) {
+      result.skipped.push(relativePath);
+      continue;
+    }
+
+    const content = await renderFileContent(sourcePath, project);
+
+    if (!dryRun) {
+      await mkdir(dirname(destinationPath), { recursive: true });
+      await writeFile(destinationPath, content);
+    }
+
+    result[exists ? "updated" : "created"].push(relativePath);
+    manifestFiles[relativePath] = hashBuffer(content);
+  }
+
+  await createCompatibilityLinks(project.root, { adapters: normalizedAdapters, force, dryRun, result });
+
+  if (!dryRun) {
+    const existingManifest = await readManifest(project.root);
+    await writeManifest(project.root, createManifest({
+      packageName,
+      cliVersion,
+      mode,
+      adapters: normalizedAdapters ?? existingManifest?.adapters,
+      files: { ...existingManifest?.files, ...manifestFiles },
+      installedAt: existingManifest?.installedAt
+    }));
+  }
+
+  return result;
+}
+
+async function createCompatibilityLinks(root, { adapters, force, dryRun, result }) {
+  for (const [linkPath, target] of COMPATIBILITY_LINKS) {
+    const adapter = adapterForPath(linkPath);
+    if (adapters && adapter && !adapters.includes(adapter)) continue;
+
+    const destination = resolve(root, linkPath);
+    const exists = await pathExists(destination);
+
+    if (exists && !force) continue;
+
+    if (!dryRun) {
+      await mkdir(dirname(destination), { recursive: true });
+      if (exists) continue;
+      try {
+        await symlink(target, destination);
+      } catch {
+        await writeFile(destination, `Compatibility pointer. Source of truth: ${target}\n`, "utf8");
+      }
+    }
+
+    if (!exists) result.created.push(linkPath);
+  }
+}

package/src/text-template.js

@@ -0,0 +1,24 @@
+export function renderTemplate(input, project) {
+  const replacements = {
+    "[PROJECT_NAME]": project.name,
+    "[PROJECT_PURPOSE]": project.purpose,
+    "[STACK]": project.stack,
+    "[PACKAGE_MANAGER]": project.packageManager,
+    "[ARCHITECTURE_PATTERN]": project.architecturePattern,
+    "[INSTALL_COMMAND]": project.commands.install,
+    "[DEV_COMMAND]": project.commands.dev,
+    "[LINT_COMMAND]": project.commands.lint,
+    "[FORMAT_COMMAND]": project.commands.format,
+    "[TYPE_CHECK_COMMAND]": project.commands.typeCheck,
+    "[TEST_COMMAND]": project.commands.test,
+    "[BUILD_COMMAND]": project.commands.build
+  };
+
+  let output = input;
+
+  for (const [token, value] of Object.entries(replacements)) {
+    output = output.split(token).join(value);
+  }
+
+  return output;
+}

package/src/workspace-cli.js

@@ -0,0 +1,115 @@
+import { detectProject } from "./project-detection.js";
+import { installHarness } from "./template-installer.js";
+import { updateHarness } from "./harness-updater.js";
+import { runDoctorChecks } from "./doctor.js";
+import { BRAND } from "./global/brand/index.js";
+
+export async function runWorkspaceInit(options, packageManifest, packageRoot, suggestedInvocation) {
+  const project = await detectProject(options.cwd);
+  const adapters = resolveAdapters(project, options);
+  const result = await installHarness({
+    project,
+    packageRoot,
+    mode: options.mode,
+    adapters,
+    packageName: packageManifest.name,
+    cliVersion: packageManifest.version,
+    force: options.force,
+    dryRun: options.dryRun
+  });
+
+  console.log(`${BRAND.displayName} ${options.dryRun ? "plan" : "installed"} for ${project.name} (scope: workspace)`);
+  console.log(`Mode: ${result.mode}`);
+  console.log(`Adapters: ${formatAdapters(result.adapters)}`);
+  console.log(`Created: ${result.created.length}`);
+  console.log(`Skipped: ${result.skipped.length}`);
+  console.log(`Updated: ${result.updated.length}`);
+
+  if (result.skipped.length > 0 && !options.force) {
+    console.log("Existing files were preserved. Re-run with --force to overwrite.");
+  }
+
+  if (!options.dryRun) {
+    console.log(`Tracked in .harness/manifest.json. Run "${suggestedInvocation} update --scope=workspace" to apply future harness releases.`);
+  }
+}
+
+export async function runWorkspaceUpdate(options, packageManifest, packageRoot) {
+  const project = await detectProject(options.cwd);
+  const adapters = resolveAdapters(project, options, { allowManifestFallback: true });
+  const result = await updateHarness({
+    project,
+    packageRoot,
+    packageName: packageManifest.name,
+    cliVersion: packageManifest.version,
+    mode: options.modeExplicit ? options.mode : undefined,
+    adapters,
+    force: options.force,
+    dryRun: options.dryRun
+  });
+
+  console.log(`${BRAND.displayName} ${options.dryRun ? "update plan" : "updated"} for ${project.name} (scope: workspace)`);
+  console.log(`Mode: ${result.mode}`);
+  console.log(`Adapters: ${formatAdapters(result.adapters)}`);
+  console.log(`Created: ${result.created.length}`);
+  console.log(`Updated: ${result.updated.length}`);
+  console.log(`Unchanged: ${result.unchanged.length}`);
+
+  if (result.skippedModified.length > 0) {
+    console.log(`Skipped, modified locally: ${result.skippedModified.length}`);
+    console.log("Re-run with --force to overwrite locally modified files.");
+  }
+
+  if (result.skippedUntracked.length > 0) {
+    console.log(`Skipped, untracked pre-existing files: ${result.skippedUntracked.length}`);
+  }
+}
+
+export async function runWorkspaceDoctor(options) {
+  const project = await detectProject(options.cwd);
+  const { checks, ok } = await runDoctorChecks(project);
+
+  console.log(`${BRAND.displayName} doctor for ${project.name} (scope: workspace)`);
+  console.log(`Root: ${project.root}`);
+  console.log(`Package manager: ${project.packageManager}`);
+  console.log(`Stack: ${project.stack}`);
+  console.log("");
+
+  for (const check of checks) {
+    const label = check.status.toUpperCase().padEnd(8);
+    const detail = check.detail ? ` — ${check.detail}` : "";
+    console.log(`[${label}] ${check.name}${detail}`);
+  }
+
+  console.log("");
+  console.log(ok ? "Status: OK" : "Status: FAILED (missing required files)");
+
+  if (!ok) process.exitCode = 1;
+}
+
+export async function runWorkspaceDetect(options, suggestedInvocation) {
+  const project = await detectProject(options.cwd);
+  const adapters = options.allAdapters ? null : options.adapters ?? project.detectedAdapters;
+
+  console.log(`Workspace project: ${project.name}`);
+  console.log(`Root: ${project.root}`);
+  console.log(`Package manager: ${project.packageManager}`);
+  console.log(`Stack: ${project.stack}`);
+  console.log(`Detected adapters: ${formatAdapters(project.detectedAdapters)}`);
+  console.log(`Recommended adapters: ${formatAdapters(adapters)}`);
+  console.log(`Suggested workspace install: ${suggestedInvocation} install --scope=workspace --mode standard${adapters?.length ? ` --adapters ${adapters.join(",")}` : ""}`);
+}
+
+function resolveAdapters(project, options, config = {}) {
+  if (options.allAdapters) return null;
+  if (options.adapters) return options.adapters;
+  if (options.detect) return project.detectedAdapters;
+  if (config.allowManifestFallback) return undefined;
+  return null;
+}
+
+function formatAdapters(adapters) {
+  if (adapters == null) return "all";
+  if (adapters.length === 0) return "core only";
+  return adapters.join(", ");
+}