@h-rig/core 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/load-config.js

@@ -1,20 +1,23 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
 import { isBuiltin } from "module";
-import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
 import { pathToFileURL } from "url";
-import { Schema as Schema2 } from "effect";
-import { RigConfig as RigConfig2 } from "@rig/contracts";
+import { Schema as Schema3 } from "effect";
+import { RigConfig as RigConfig3 } from "@rig/contracts";
 
 // packages/core/src/define-config.ts
 import { Schema } from "effect";
 import { RigConfig } from "@rig/contracts";
 function normalizeWorkspaceConfig(raw) {
-  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
-  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
-  workspace.isolation = workspace.isolation ?? workspace.checkout;
-  workspace.sandbox = workspace.sandbox ?? "enforce";
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
   return workspace;
 }
 function applyConfigDefaults(raw) {
@@ -28,6 +31,64 @@ function applyConfigDefaults(raw) {
   };
 }
 
+// packages/core/src/declarative-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+
+// packages/core/src/declarative-config.ts
+var DECLARATIVE_CONFIG_NAMES = ["rigfig.toml", "rigfig.json"];
+function findDeclarativeConfigPath(cwd) {
+  const dir = join(cwd, ".rig");
+  for (const name of DECLARATIVE_CONFIG_NAMES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseDeclarativeFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = path.endsWith(".json") ? JSON.parse(raw) : parseToml(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Declarative config ${path} must parse to an object.`);
+  }
+  return parsed;
+}
+function loadDeclarativeConfig(path) {
+  const data = parseDeclarativeFile(path);
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
+  const useStandard = standardSection.enabled !== false;
+  let plugins = [];
+  if (useStandard) {
+    const resolver = getStandardPluginsResolver();
+    if (!resolver) {
+      throw new Error(`Declarative config ${path} needs the embedded standard plugins, but none were registered. ` + `This is a seed/boot wiring error (the binary entrypoint must import the standard-plugin registration).`);
+    }
+    plugins = resolver(data);
+  }
+  const { standard: _standardDirective, ...configFields } = data;
+  const withDefaults = applyConfigDefaults({ ...configFields, plugins });
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
 // packages/core/src/load-config.ts
 var TS_NAMES = ["rig.config.ts", "rig.config.mts"];
 var JSON_NAMES = ["rig.config.json"];
@@ -89,18 +150,18 @@ function exportTargetFromPackageJson(pkg, subpath) {
   return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
 }
 function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
-  const storeDir = join(nodeModulesDir, ".bun");
-  if (!existsSync(storeDir))
+  const storeDir = join2(nodeModulesDir, ".bun");
+  if (!existsSync2(storeDir))
     return null;
   const encoded = packageName.replace("/", "+");
   try {
     const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
-      const candidateDir = join(storeDir, entry, "node_modules", packageName);
-      const packageJsonPath = join(candidateDir, "package.json");
-      if (!existsSync(packageJsonPath))
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
         return null;
       try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
         return {
           dir: candidateDir,
           sortKey: pkg.version?.trim() || entry
@@ -118,30 +179,30 @@ function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
   }
 }
 function resolveDirectoryModulePath(directoryPath) {
-  const packageJsonPath = join(directoryPath, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, ".");
       if (target) {
-        const resolved = resolveModulePath(join(directoryPath, target));
+        const resolved = resolveModulePath(join2(directoryPath, target));
         if (resolved)
           return resolved;
       }
     } catch {}
   }
   for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
-    const resolved = resolveModulePath(join(directoryPath, candidate));
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
     if (resolved)
       return resolved;
   }
   return null;
 }
 function resolveModulePath(candidatePath) {
-  if (!existsSync(candidatePath)) {
+  if (!existsSync2(candidatePath)) {
     for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
       const withExtension = `${candidatePath}${extension}`;
-      if (existsSync(withExtension))
+      if (existsSync2(withExtension))
         return resolveModulePath(withExtension);
     }
     return null;
@@ -158,13 +219,13 @@ function resolveModulePath(candidatePath) {
   return null;
 }
 function resolvePackageExportFromDir(packageDir, subpath) {
-  const packageJsonPath = join(packageDir, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, subpath);
       if (target) {
-        const resolved = resolveModulePath(join(packageDir, target));
+        const resolved = resolveModulePath(join2(packageDir, target));
         if (resolved)
           return resolved;
       }
@@ -175,12 +236,12 @@ function resolvePackageExportFromDir(packageDir, subpath) {
   if (subpath !== ".") {
     const legacySubpath = subpath.replace(/^\.\//, "");
     for (const candidate of [
-      join(packageDir, legacySubpath),
-      join(packageDir, `${legacySubpath}.js`),
-      join(packageDir, `${legacySubpath}.mjs`),
-      join(packageDir, `${legacySubpath}.cjs`),
-      join(packageDir, `${legacySubpath}.ts`),
-      join(packageDir, `${legacySubpath}.json`)
+      join2(packageDir, legacySubpath),
+      join2(packageDir, `${legacySubpath}.js`),
+      join2(packageDir, `${legacySubpath}.mjs`),
+      join2(packageDir, `${legacySubpath}.cjs`),
+      join2(packageDir, `${legacySubpath}.ts`),
+      join2(packageDir, `${legacySubpath}.json`)
     ]) {
       const resolved = resolveModulePath(candidate);
       if (resolved)
@@ -215,32 +276,62 @@ function resolveProjectPackageImport(specifier, configDir) {
   const parsed = packageNameAndSubpath(specifier);
   if (!parsed)
     return null;
-  const nodeModulesDir = join(configDir, "node_modules");
-  const directPackageDir = join(nodeModulesDir, parsed.packageName);
-  const packageDir = existsSync(join(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  const nodeModulesDir = join2(configDir, "node_modules");
+  const directPackageDir = join2(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync2(join2(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
   return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
 }
+function canImportRigWorkspacePackagesDirectly(source, configDir) {
+  const packageNames = new Set;
+  for (const match of source.matchAll(/(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g)) {
+    const parsed = packageNameAndSubpath(match[1] ?? "");
+    if (parsed?.packageName)
+      packageNames.add(parsed.packageName);
+  }
+  if (packageNames.size === 0)
+    return false;
+  for (const packageName of packageNames) {
+    const shortName = packageName.replace(/^@rig\//, "");
+    const manifestPath = join2(configDir, "packages", shortName, "package.json");
+    if (!existsSync2(manifestPath))
+      return false;
+    try {
+      const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      if (parsed.name !== packageName)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 async function importConfigViaRuntimeBundleUnserialized(configPath) {
   const bun = globalThis.Bun;
   if (!bun?.build) {
     throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
   }
-  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
   const configDir = dirname(configPath);
   const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
   const unresolvedLocalPlugin = {
     name: "rig-config-unresolved-local",
     setup(build) {
+      build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
       build.onResolve({ filter: /.*/ }, (args) => {
         const directFilePath = resolvedFilePath(args.path, configDir);
         if (directFilePath)
           return { path: directFilePath };
         const packageImport = packageNameAndSubpath(args.path);
-        if (packageImport && RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
           return { path: args.path, external: true };
+        }
         const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
         if (projectPackagePath)
-          return packageImport?.packageName.startsWith("@oh-my-pi/") ? { path: projectPackagePath, external: true } : { path: projectPackagePath };
+          return { path: projectPackagePath };
         if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
           return;
         if (packageImport)
@@ -271,7 +362,7 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   const result = await bun.build({
     entrypoints: [configPath],
     target: "bun",
-    external: ["mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
     format: "esm",
     throw: false,
     packages: "bundle",
@@ -282,11 +373,11 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
 `);
     throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
   }
-  const bundleParentDir = join(configDir, ".rig", "tmp");
+  const bundleParentDir = join2(configDir, ".rig", "tmp");
   mkdirSync(bundleParentDir, { recursive: true });
-  const dir = mkdtempSync(join(bundleParentDir, "rig-config-bundle-"));
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
   try {
-    const bundledPath = join(dir, "rig.config.bundled.js");
+    const bundledPath = join2(dir, "rig.config.bundled.js");
     await bun.write(bundledPath, await result.outputs[0].text());
     return await import(pathToFileURL(bundledPath).href);
   } finally {
@@ -296,16 +387,20 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   }
 }
 async function loadConfig(cwd) {
+  const baked = getEmbeddedProjectConfig();
+  if (baked && resolve(baked.projectRoot) === resolve(cwd)) {
+    return decodeExplicitPluginConfig(baked.raw);
+  }
   for (const name of TS_NAMES) {
-    const p = join(cwd, name);
-    if (existsSync(p)) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
       const mod = await enqueueRuntimeBundle(async () => {
         if (runningFromCompiledBinary()) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
-        const source = readFileSync(p, "utf8");
+        const source = readFileSync2(p, "utf8");
         const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
-        if (importsRigHostPackages) {
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
         try {
@@ -320,19 +415,23 @@ async function loadConfig(cwd) {
       return decodeExplicitPluginConfig(raw);
     }
   }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
   for (const name of JSON_NAMES) {
-    const p = join(cwd, name);
-    if (existsSync(p)) {
-      const raw = JSON.parse(readFileSync(p, "utf-8"));
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const raw = JSON.parse(readFileSync2(p, "utf-8"));
       return decodeExplicitPluginConfig(raw);
     }
   }
-  throw new Error(`no rig.config.{ts,mts,json} found in ${cwd}`);
+  throw new Error(`no rig.config.{ts,mts,json} or .rig/rigfig.{toml,json} found in ${cwd}`);
 }
 function decodeExplicitPluginConfig(raw) {
   const withDefaults = applyConfigDefaults(raw);
   const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
-  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
     ...withDefaults,
     plugins: explicitPlugins
   });

package/dist/src/placement.d.ts

@@ -0,0 +1,50 @@
+export type PlacementKind = "local" | "remote";
+export type Placement = {
+    readonly alias: string;
+    readonly kind: PlacementKind;
+    readonly host?: string | null;
+    readonly port?: number | null;
+    readonly baseUrl?: string | null;
+    readonly projectRoot?: string | null;
+    readonly status?: string | null;
+    readonly taskSource?: string | null;
+};
+export type RepoConnectionState = {
+    selected: string;
+    project?: string;
+    linkedAt?: string;
+    serverProjectRoot?: string;
+    serverProjectRootAlias?: string;
+    serverProjectRootBaseUrl?: string;
+};
+export type AddPlacementInput = {
+    readonly alias: string;
+    readonly host: string;
+    readonly port?: number;
+    readonly token?: string | null;
+    readonly select?: boolean;
+};
+export declare function resolveRepoConnectionPath(projectRoot: string): string;
+export declare function readSelection(projectRoot: string): RepoConnectionState | null;
+export declare const readRepoConnection: typeof readSelection;
+export declare function writeSelection(projectRoot: string, state: RepoConnectionState): void;
+export declare const writeRepoConnection: typeof writeSelection;
+export declare function readPlacement(projectRoot: string, env?: NodeJS.ProcessEnv): Promise<Placement>;
+export declare const readSelectedTarget: typeof readPlacement;
+export declare function listPlacements(projectRoot: string): Placement[];
+export declare const listServerTargets: typeof listPlacements;
+export declare function selectPlacement(projectRoot: string, alias: string, options?: {
+    dryRun?: boolean;
+}): Placement;
+export declare const selectServerTarget: typeof selectPlacement;
+export declare function addPlacement(projectRoot: string, input: AddPlacementInput, options?: {
+    dryRun?: boolean;
+}): Placement;
+export declare const addRemoteTarget: typeof addPlacement;
+export declare function removePlacement(projectRoot: string, alias: string, options?: {
+    dryRun?: boolean;
+}): {
+    readonly alias: string;
+    readonly removed: boolean;
+};
+export declare const removeServerTarget: typeof removePlacement;