@rigkit/cli 0.2.7 → 0.2.8

package/src/project.test.ts

@@ -5,17 +5,17 @@ import { join } from "node:path";
 import { discoverProjectConfigs, resolveConfigPaths } from "./project.ts";
 
 describe("CLI project resolution", () => {
-  test("resolves -C to that directory's rig.config.ts", () => {
+  test("resolves -chdir to that directory's rig.config.ts", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
     mkdirSync(join(cwd, "example"));
     writeFileSync(join(cwd, "example", "rig.config.ts"), "export default {}\n");
-    const paths = resolveConfigPaths({ cwd, project: "example" });
+    const paths = resolveConfigPaths({ cwd, chdir: "example" });
 
     expect(paths.projectDir).toBe(join(cwd, "example"));
     expect(paths.configPath).toBe(join(cwd, "example", "rig.config.ts"));
   });
 
-  test("resolves --config project root from the config dirname", () => {
+  test("resolves -config project root from the config dirname", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
     const paths = resolveConfigPaths({ cwd, config: "machines/platform.ts" });
 
@@ -34,6 +34,16 @@ describe("CLI project resolution", () => {
     expect(paths.configPath).toBe(join(cwd, "project", "rig.config.ts"));
   });
 
+  test("reports named configs when the default config is missing", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
+    writeFileSync(join(cwd, "api.rig.config.ts"), "export default {}\n");
+    writeFileSync(join(cwd, "web.rig.config.ts"), "export default {}\n");
+
+    expect(() => resolveConfigPaths({ cwd })).toThrow(
+      /Found named Rigkit configs[\s\S]*api\.rig\.config\.ts[\s\S]*web\.rig\.config\.ts[\s\S]*rig -chdir=\. -config=api\.rig\.config\.ts <command>/,
+    );
+  });
+
   test("discovers projects downward without entering dependency directories", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
     mkdirSync(join(cwd, "api"), { recursive: true });
@@ -48,4 +58,24 @@ describe("CLI project resolution", () => {
       configPath: join(cwd, "api", "rig.config.ts"),
     }]);
   });
+
+  test("discovers named configs downward", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
+    mkdirSync(join(cwd, "global-fragments"), { recursive: true });
+    writeFileSync(join(cwd, "global-fragments", "api.rig.config.ts"), "export default {}\n");
+    writeFileSync(join(cwd, "global-fragments", "web.rig.config.ts"), "export default {}\n");
+
+    const projects = discoverProjectConfigs({ cwd });
+
+    expect(projects).toEqual([
+      {
+        projectDir: join(cwd, "global-fragments"),
+        configPath: join(cwd, "global-fragments", "api.rig.config.ts"),
+      },
+      {
+        projectDir: join(cwd, "global-fragments"),
+        configPath: join(cwd, "global-fragments", "web.rig.config.ts"),
+      },
+    ]);
+  });
 });

package/src/project.ts

@@ -1,4 +1,4 @@
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { existsSync, readdirSync } from "node:fs";
 
 export const DEFAULT_CONFIG_FILE = "rig.config.ts";
@@ -8,7 +8,7 @@ export const FREESTYLE_SDK_PACKAGE_NAME = "freestyle";
 export const FREESTYLE_SDK_PACKAGE_VERSION = "^0.1.51";
 
 export type ConfigPathOptions = {
-  project?: string;
+  chdir?: string;
   config?: string;
   cwd?: string;
 };
@@ -22,20 +22,23 @@ export type DiscoveredProject = ResolvedConfigPaths;
 
 export function resolveConfigPaths(options: ConfigPathOptions): ResolvedConfigPaths {
   const cwd = resolve(options.cwd ?? process.cwd());
+  const workingDir = options.chdir ? resolve(cwd, options.chdir) : cwd;
   if (options.config) {
-    const projectBase = options.project ? resolve(cwd, options.project) : cwd;
-    const configPath = resolve(projectBase, options.config);
+    const configPath = resolve(workingDir, options.config);
     return {
       projectDir: dirname(configPath),
       configPath,
     };
   }
 
-  const projectDir = options.project ? resolve(cwd, options.project) : findNearestProjectDir(cwd);
+  const projectDir = options.chdir ? workingDir : findNearestProjectDir(workingDir);
   const configPath = join(projectDir, DEFAULT_CONFIG_FILE);
 
   if (!existsSync(configPath)) {
-    throw new Error(`No Rigkit config found at ${configPath}. Run "rig init" or pass --config <file>.`);
+    throw new Error(formatConfigNotFoundAt(configPath, {
+      commandCwd: cwd,
+      hint: namedRigConfigFilesHint(projectDir),
+    }));
   }
 
   return {
@@ -48,7 +51,7 @@ export function discoverProjectConfigs(options: ConfigPathOptions = {}): Discove
   if (options.config) return [resolveConfigPaths(options)];
 
   const cwd = resolve(options.cwd ?? process.cwd());
-  const root = resolve(cwd, options.project ?? ".");
+  const root = resolve(cwd, options.chdir ?? ".");
   const projects: DiscoveredProject[] = [];
   visitProjectDirs(root, projects);
   return projects.sort((left, right) => left.configPath.localeCompare(right.configPath));
@@ -56,20 +59,24 @@ export function discoverProjectConfigs(options: ConfigPathOptions = {}): Discove
 
 function findNearestProjectDir(start: string): string {
   let current = start;
+  let hint: ConfigFilesHint | undefined;
   for (;;) {
     if (existsSync(join(current, DEFAULT_CONFIG_FILE))) return current;
+    hint ??= namedRigConfigFilesHint(current);
     const parent = dirname(current);
     if (parent === current) {
-      throw new Error(`No Rigkit config found from ${start} upward. Run "rig init" or pass --config <file>.`);
+      throw new Error(formatConfigNotFoundFrom(start, { commandCwd: start, hint }));
     }
     current = parent;
   }
 }
 
 function visitProjectDirs(dir: string, projects: DiscoveredProject[]): void {
-  const configPath = join(dir, DEFAULT_CONFIG_FILE);
-  if (existsSync(configPath)) {
-    projects.push({ projectDir: dir, configPath });
+  const configFiles = rigConfigFilesInDir(dir);
+  if (configFiles.length > 0) {
+    for (const configFile of configFiles) {
+      projects.push({ projectDir: dir, configPath: join(dir, configFile) });
+    }
     return;
   }
 
@@ -94,3 +101,84 @@ function shouldSkipDiscoveryDir(name: string): boolean {
     name === "dist" ||
     name === "build";
 }
+
+export function rigConfigFilesInDir(dir: string): string[] {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  return entries
+    .filter((entry) => entry.isFile() && isRigConfigFileName(entry.name))
+    .map((entry) => entry.name)
+    .sort((left, right) => {
+      if (left === DEFAULT_CONFIG_FILE) return -1;
+      if (right === DEFAULT_CONFIG_FILE) return 1;
+      return left.localeCompare(right);
+    });
+}
+
+export function isRigConfigFileName(name: string): boolean {
+  return name === DEFAULT_CONFIG_FILE || name.endsWith(".rig.config.ts");
+}
+
+type ConfigFilesHint = {
+  dir: string;
+  files: string[];
+};
+
+function namedRigConfigFilesHint(dir: string): ConfigFilesHint | undefined {
+  const files = rigConfigFilesInDir(dir).filter((file) => file !== DEFAULT_CONFIG_FILE);
+  return files.length > 0 ? { dir, files } : undefined;
+}
+
+function formatConfigNotFoundAt(
+  configPath: string,
+  options: { commandCwd: string; hint?: ConfigFilesHint },
+): string {
+  return appendConfigFilesHint(
+    `No Rigkit config found at ${configPath}.`,
+    options,
+  );
+}
+
+function formatConfigNotFoundFrom(
+  start: string,
+  options: { commandCwd: string; hint?: ConfigFilesHint },
+): string {
+  return appendConfigFilesHint(
+    `No Rigkit config found from ${start} upward.`,
+    options,
+  );
+}
+
+function appendConfigFilesHint(
+  message: string,
+  options: { commandCwd: string; hint?: ConfigFilesHint },
+): string {
+  const hint = options.hint;
+  if (!hint) return `${message} Run "rig init" or pass -config=<file>.`;
+
+  const configFile = hint.files[0]!;
+  const configPath = displayPath(options.commandCwd, join(hint.dir, configFile));
+  const projectDir = displayPath(options.commandCwd, hint.dir);
+
+  return [
+    message,
+    `Found named Rigkit configs in ${hint.dir}:`,
+    ...hint.files.map((file) => `- ${file}`),
+    "",
+    "Choose one explicitly:",
+    `  rig -config=${configPath} <command>`,
+    `  rig -chdir=${projectDir} -config=${configFile} <command>`,
+  ].join("\n");
+}
+
+function displayPath(from: string, path: string): string {
+  const relativePath = relative(from, path);
+  if (!relativePath) return ".";
+  if (!relativePath.startsWith("..") && !isAbsolute(relativePath)) return relativePath;
+  return path;
+}

package/src/run-logger.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { appendFileSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRunLogger } from "./run-logger.ts";
+
+describe("createRunLogger", () => {
+  test("writes a run.start envelope, every appended event, and a run.end envelope", () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-run-logger-"));
+    try {
+      const logger = createRunLogger({ projectDir, operation: "plan" });
+      expect(logger).toBeDefined();
+      logger!.append({ type: "node.started", nodePath: "build" });
+      logger!.append({ type: "node.completed", nodePath: "build" });
+      logger!.finish({ status: "completed", result: { ok: true } });
+      logger!.close();
+
+      const lines = readFileSync(logger!.path, "utf8").trim().split("\n");
+      expect(lines.length).toBe(4);
+      const entries = lines.map((line) => JSON.parse(line));
+      expect(entries[0]).toMatchObject({ type: "run.start", operation: "plan" });
+      expect(entries[1]).toMatchObject({ type: "node.started", nodePath: "build" });
+      expect(entries[2]).toMatchObject({ type: "node.completed", nodePath: "build" });
+      expect(entries[3]).toMatchObject({ type: "run.end", status: "completed", result: { ok: true } });
+
+      const logFiles = readdirSync(join(projectDir, ".rigkit", "logs"));
+      expect(logFiles.length).toBe(1);
+    } finally {
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  test("captures failure details on the run.end envelope", () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-run-logger-"));
+    try {
+      const logger = createRunLogger({ projectDir, operation: "apply" });
+      logger!.append({ type: "run.failed", error: { message: "boom" } });
+      logger!.finish({ status: "failed", error: new Error("boom") });
+      logger!.close();
+
+      const entries = readFileSync(logger!.path, "utf8").trim().split("\n").map((line) => JSON.parse(line));
+      expect(entries.at(-1)).toMatchObject({
+        type: "run.end",
+        status: "failed",
+        error: { message: "boom" },
+      });
+    } finally {
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  test("splices daemon stderr written during the run into the failure log", () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-run-logger-"));
+    const daemonStderrPath = join(projectDir, "daemon.log");
+    // Pre-existing daemon output that predates the run — we must NOT splice it.
+    writeFileSync(daemonStderrPath, "earlier daemon noise we should ignore\n");
+
+    try {
+      const logger = createRunLogger({ projectDir, operation: "apply", daemonStderrPath });
+      // Daemon writes a real stack trace mid-run.
+      appendFileSync(daemonStderrPath, "Error: connect ECONNREFUSED 127.0.0.1:443\n    at fetch (engine.ts:42)\n");
+      logger!.finish({ status: "failed", error: new Error("INTERNAL_ERROR: Internal server error") });
+      logger!.close();
+
+      const entries = readFileSync(logger!.path, "utf8").trim().split("\n").map((line) => JSON.parse(line));
+      const stderr = entries.filter((entry) => entry.type === "daemon.stderr").map((entry) => entry.data);
+      expect(stderr).toEqual([
+        "Error: connect ECONNREFUSED 127.0.0.1:443",
+        "    at fetch (engine.ts:42)",
+      ]);
+      expect(stderr.some((line) => line.includes("earlier daemon noise"))).toBe(false);
+    } finally {
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  test("does not splice daemon stderr on success", () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-run-logger-"));
+    const daemonStderrPath = join(projectDir, "daemon.log");
+    try {
+      const logger = createRunLogger({ projectDir, operation: "apply", daemonStderrPath });
+      appendFileSync(daemonStderrPath, "noise during a successful run\n");
+      logger!.finish({ status: "completed" });
+      logger!.close();
+
+      const entries = readFileSync(logger!.path, "utf8").trim().split("\n").map((line) => JSON.parse(line));
+      expect(entries.find((entry) => entry.type === "daemon.stderr")).toBeUndefined();
+    } finally {
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/run-logger.ts

@@ -0,0 +1,203 @@
+// Persists every runtime event for a single run to `.rigkit/logs/`. The
+// presenter on stderr stays terse; this file is the unfiltered transcript you
+// grep when something goes wrong. NDJSON, one event per line, plus a couple of
+// envelope records (run.start / run.end) so logs stand on their own.
+//
+// On failure we also splice in the daemon's stderr emitted during this run's
+// time window. The daemon's "INTERNAL_ERROR: Internal server error" event
+// carries no stack — the real trace is in its stderr. We capture that to
+// `runtimeLogPath` (in runtime-client) and tail it here so the run log is
+// self-contained.
+
+import {
+  appendFileSync,
+  closeSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+
+const LOG_DIR_NAME = "logs";
+const MAX_LOG_FILES = 50;
+
+export type RunLogger = {
+  append(event: unknown): void;
+  finish(outcome: { status: "completed" | "failed"; error?: unknown; result?: unknown }): void;
+  close(): void;
+  path: string;
+};
+
+export function createRunLogger(input: {
+  projectDir: string;
+  operation: string;
+  runtimeStateDir?: string;
+  // Daemon stderr file. When the run fails we splice everything written here
+  // during this run's time window into the run log.
+  daemonStderrPath?: string;
+}): RunLogger | undefined {
+  const logDir = resolveLogDir(input);
+  if (!logDir) return undefined;
+
+  try {
+    mkdirSync(logDir, { recursive: true });
+  } catch {
+    return undefined;
+  }
+
+  const path = join(logDir, `${fileTimestamp()}-${slugify(input.operation)}.log`);
+
+  let fd: number;
+  try {
+    fd = openSync(path, "a");
+  } catch {
+    return undefined;
+  }
+
+  rotate(logDir);
+
+  const startedAt = new Date().toISOString();
+  // Snapshot the daemon log's current size so we can read only what this run
+  // appended later. We don't want to dump the daemon's entire history.
+  const daemonOffset = input.daemonStderrPath ? safeFileSize(input.daemonStderrPath) : 0;
+  let closed = false;
+
+  const writeLine = (value: unknown): void => {
+    if (closed) return;
+    try {
+      appendFileSync(fd, `${JSON.stringify(value)}\n`);
+    } catch {
+      // best-effort: a logging failure should never break the run
+    }
+  };
+
+  writeLine({
+    ts: startedAt,
+    type: "run.start",
+    operation: input.operation,
+    cwd: process.cwd(),
+  });
+
+  return {
+    path,
+    append(event) {
+      writeLine({ ts: new Date().toISOString(), ...(toRecord(event) ?? { value: event }) });
+    },
+    finish(outcome) {
+      if (outcome.status === "failed" && input.daemonStderrPath) {
+        spliceDaemonStderr(input.daemonStderrPath, daemonOffset, writeLine);
+      }
+      writeLine({
+        ts: new Date().toISOString(),
+        type: "run.end",
+        status: outcome.status,
+        durationMs: Date.now() - Date.parse(startedAt),
+        ...(outcome.error !== undefined ? { error: toErrorRecord(outcome.error) } : {}),
+        ...(outcome.result !== undefined ? { result: outcome.result } : {}),
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try {
+        closeSync(fd);
+      } catch {
+        // best-effort
+      }
+    },
+  };
+}
+
+function spliceDaemonStderr(
+  path: string,
+  offset: number,
+  write: (value: unknown) => void,
+): void {
+  let fd: number | undefined;
+  try {
+    const size = safeFileSize(path);
+    if (size <= offset) return;
+    fd = openSync(path, "r");
+    const length = size - offset;
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, offset);
+    const text = buffer.toString("utf8");
+    for (const line of text.split("\n")) {
+      if (!line) continue;
+      write({ ts: new Date().toISOString(), type: "daemon.stderr", data: line });
+    }
+  } catch {
+    // best-effort: failure to splice should never break the run log
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {
+        // best-effort
+      }
+    }
+  }
+}
+
+function safeFileSize(path: string): number {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+function resolveLogDir(input: { projectDir: string; runtimeStateDir?: string }): string | undefined {
+  if (input.runtimeStateDir) return join(input.runtimeStateDir, LOG_DIR_NAME);
+  if (input.projectDir) return join(input.projectDir, ".rigkit", LOG_DIR_NAME);
+  return undefined;
+}
+
+function rotate(logDir: string): void {
+  try {
+    const entries = readdirSync(logDir)
+      .filter((name) => name.endsWith(".log"))
+      .map((name) => {
+        const filePath = join(logDir, name);
+        return { path: filePath, mtime: statSync(filePath).mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+
+    for (const stale of entries.slice(MAX_LOG_FILES)) {
+      try {
+        unlinkSync(stale.path);
+      } catch {
+        // best-effort
+      }
+    }
+  } catch {
+    // best-effort
+  }
+}
+
+function fileTimestamp(): string {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function slugify(value: string): string {
+  const cleaned = value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  const slug = cleaned.slice(0, 40);
+  return slug || "run";
+}
+
+function toRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function toErrorRecord(value: unknown): Record<string, unknown> {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack };
+  }
+  const record = toRecord(value);
+  return record ?? { message: String(value) };
+}