@lunora/cli 1.0.0-alpha.90 → 1.0.0-alpha.92

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './packem_shared/COMMANDS-DZ0NnuqI.mjs';
+import { runCli } from './packem_shared/COMMANDS-CstRNuDU.mjs';
 
 try {
   const code = await runCli();

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { COMMANDS, VERSION, runCli } from './packem_shared/COMMANDS-DZ0NnuqI.mjs';
+export { COMMANDS, VERSION, runCli } from './packem_shared/COMMANDS-CstRNuDU.mjs';
 export { runCodegenCommand } from './packem_chunks/runCodegenCommand.mjs';
 export { DEFAULT_IMPORT_BATCH_SIZE, runExportCommand, runImportCommand } from './packem_shared/DEFAULT_IMPORT_BATCH_SIZE-D0VOTerB.mjs';
 export { runDeployCommand } from './packem_chunks/runDeployCommand.mjs';

package/dist/packem_chunks/handler15.mjs

@@ -1,60 +1,100 @@
-import { readLinkedProject } from '@lunora/config';
+import { runCodegen } from '@lunora/codegen';
+import { validateWranglerProject, inferLunoraBindings, reconcileWranglerBindings, reconcileWranglerCompatibilityDate, reconcileWranglerCrons } from '@lunora/config';
+import { p as parseApiSpec } from '../packem_shared/api-spec-Bx0iKbxA.mjs';
+import { r as renderCodegenFailure } from '../packem_shared/codegen-error-DJG-ghs_.mjs';
 import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
-import { e as execArgsFor, d as detectPackageManager } from '../packem_shared/detect-package-manager-v4hHpQd0.mjs';
-import { defaultSpawner } from '../packem_shared/createRecordingSpawner-WuSn20kb.mjs';
+import { r as runSchemaDriftGate } from '../packem_shared/schema-drift-gate-BtBt0as0.mjs';
 
-const LOG_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
-const runLogsCommand = async (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  if (options.format !== void 0 && !LOG_FORMATS.has(options.format)) {
-    options.logger.error(`logs: unknown --format "${options.format}" — expected pretty | json`);
-    return { code: 1, descriptor: void 0, error: "invalid format" };
-  }
-  const args = ["tail"];
-  if (options.worker !== void 0) {
-    args.push(options.worker);
+const provisionBindings = async (cwd, logger, cronTriggers = []) => {
+  try {
+    const inferred = await inferLunoraBindings({ projectRoot: cwd });
+    const reconciled = reconcileWranglerBindings(cwd, inferred);
+    if (reconciled.changed) {
+      logger.success(`provisioned bindings: ${reconciled.added.join(", ")} → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`);
+    }
+    for (const warning of reconciled.warnings) {
+      logger.warn(warning);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`binding inference skipped: ${message}`);
   }
-  const env = options.env ?? readLinkedProject(cwd)?.env;
-  if (env !== void 0) {
-    args.push("--env", env);
+  try {
+    const reconciled = reconcileWranglerCompatibilityDate(cwd);
+    if (reconciled.changed) {
+      logger.success(
+        `bumped compatibility_date to ${reconciled.date ?? "unknown"} (Workers Cache enabled) → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`compatibility date sync skipped: ${message}`);
   }
-  if (options.format !== void 0) {
-    args.push("--format", options.format);
+  try {
+    const reconciled = reconcileWranglerCrons(cwd, cronTriggers);
+    if (reconciled.changed) {
+      logger.success(`synced ${String(cronTriggers.length)} cron trigger(s) → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`cron trigger sync skipped: ${message}`);
   }
-  if (options.status !== void 0) {
-    args.push("--status", options.status);
+};
+const runPrepareCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  options.logger.info("running codegen");
+  let codegen;
+  try {
+    codegen = runCodegen({ apiSpec: options.apiSpec, projectRoot: cwd });
+    options.logger.success("codegen complete");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    options.logger.error(renderCodegenFailure(error));
+    return {
+      code: 1,
+      error: `codegen failed: ${message}`,
+      validation: { problems: [], wranglerPath: void 0 }
+    };
   }
-  if (options.search !== void 0) {
-    args.push("--search", options.search);
+  const gate = runSchemaDriftGate({
+    allowDrift: options.allowSchemaDrift === true,
+    codegen,
+    logger: options.logger,
+    updateBaseline: options.updateSchemaBaseline === true
+  });
+  if (gate.blocked) {
+    return {
+      code: 1,
+      error: "schema drift gate blocked prepare",
+      schemaDrift: { blocked: true, reason: gate.reason },
+      validation: { problems: [], wranglerPath: void 0 }
+    };
   }
-  if (options.temporary) {
-    args.push("--temporary");
+  await provisionBindings(cwd, options.logger, codegen.cronTriggers);
+  const validation = validateWranglerProject({ projectRoot: cwd });
+  if (validation.problems.length > 0) {
+    options.logger.error("wrangler.jsonc validation failed:");
+    for (const problem of validation.problems) {
+      options.logger.error(`  - ${problem}`);
+    }
+    return {
+      code: 1,
+      error: "wrangler validation failed",
+      validation
+    };
   }
-  const exec = execArgsFor(detectPackageManager(cwd), "wrangler", args);
-  const descriptor = {
-    args: exec.args,
-    command: exec.command,
-    cwd
-  };
-  options.logger.info(`tailing logs via ${descriptor.command} ${descriptor.args.join(" ")}`);
-  const spawner = options.spawner ?? defaultSpawner;
-  const result = await spawner(descriptor);
-  return {
-    code: result.code,
-    descriptor
-  };
+  gate.rebless?.();
+  options.logger.success("project is ready to deploy");
+  return { code: 0, validation };
 };
 const execute = defineHandler(
-  ({ argument, cwd, logger, options }) => runLogsCommand({
+  ({ cwd, logger, options }) => runPrepareCommand({
+    allowSchemaDrift: options.allowSchemaDrift === true,
+    apiSpec: parseApiSpec(options.apiSpec),
     cwd,
-    env: options.env,
-    format: options.format,
     logger,
-    search: options.search,
-    status: options.status,
-    temporary: options.temporary === true,
-    worker: argument[0]
+    updateSchemaBaseline: options.updateSchemaBaseline === true
   })
 );
 
-export { execute, runLogsCommand };
+export { execute, runPrepareCommand };

package/dist/packem_chunks/handler16.mjs

@@ -1,100 +1,44 @@
-import { runCodegen } from '@lunora/codegen';
-import { validateWranglerProject, inferLunoraBindings, reconcileWranglerBindings, reconcileWranglerCompatibilityDate, reconcileWranglerCrons } from '@lunora/config';
-import { p as parseApiSpec } from '../packem_shared/api-spec-Bx0iKbxA.mjs';
-import { r as renderCodegenFailure } from '../packem_shared/codegen-error-DJG-ghs_.mjs';
 import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
-import { r as runSchemaDriftGate } from '../packem_shared/schema-drift-gate-BtBt0as0.mjs';
+import { r as runAddCommand, b as runRegistryViewCommand, a as runBuildIndexCommand } from '../packem_shared/commands-D5Yxt9VY.mjs';
 
-const provisionBindings = async (cwd, logger, cronTriggers = []) => {
-  try {
-    const inferred = await inferLunoraBindings({ projectRoot: cwd });
-    const reconciled = reconcileWranglerBindings(cwd, inferred);
-    if (reconciled.changed) {
-      logger.success(`provisioned bindings: ${reconciled.added.join(", ")} → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`);
-    }
-    for (const warning of reconciled.warnings) {
-      logger.warn(warning);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn(`binding inference skipped: ${message}`);
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const subcommand = argument[0];
+  const names = argument.slice(1);
+  if (subcommand === "add") {
+    return runAddCommand({
+      allowUnsafeSource: options.allowUnsafeSource === true,
+      cwd,
+      diff: options.diff === true,
+      dryRun: options.dryRun === true,
+      from: options.from,
+      json: options.json === true,
+      logger,
+      names,
+      overwrite: options.overwrite === true,
+      ref: options.ref,
+      source: options.source,
+      yes: options.yes === true
+    });
   }
-  try {
-    const reconciled = reconcileWranglerCompatibilityDate(cwd);
-    if (reconciled.changed) {
-      logger.success(
-        `bumped compatibility_date to ${reconciled.date ?? "unknown"} (Workers Cache enabled) → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`
-      );
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn(`compatibility date sync skipped: ${message}`);
+  if (subcommand === "list") {
+    return runAddCommand({ cwd, from: options.from, json: options.json === true, list: true, logger, names: [], ref: options.ref, source: options.source });
   }
-  try {
-    const reconciled = reconcileWranglerCrons(cwd, cronTriggers);
-    if (reconciled.changed) {
-      logger.success(`synced ${String(cronTriggers.length)} cron trigger(s) → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn(`cron trigger sync skipped: ${message}`);
+  if (subcommand === "view") {
+    return runRegistryViewCommand({
+      allowUnsafeSource: options.allowUnsafeSource === true,
+      cwd,
+      from: options.from,
+      logger,
+      names,
+      ref: options.ref,
+      source: options.source
+    });
   }
-};
-const runPrepareCommand = async (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  options.logger.info("running codegen");
-  let codegen;
-  try {
-    codegen = runCodegen({ apiSpec: options.apiSpec, projectRoot: cwd });
-    options.logger.success("codegen complete");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    options.logger.error(renderCodegenFailure(error));
-    return {
-      code: 1,
-      error: `codegen failed: ${message}`,
-      validation: { problems: [], wranglerPath: void 0 }
-    };
+  if (subcommand === "build") {
+    return runBuildIndexCommand({ check: options.check === true, from: options.from, logger, out: options.out });
   }
-  const gate = runSchemaDriftGate({
-    allowDrift: options.allowSchemaDrift === true,
-    codegen,
-    logger: options.logger,
-    updateBaseline: options.updateSchemaBaseline === true
-  });
-  if (gate.blocked) {
-    return {
-      code: 1,
-      error: "schema drift gate blocked prepare",
-      schemaDrift: { blocked: true, reason: gate.reason },
-      validation: { problems: [], wranglerPath: void 0 }
-    };
-  }
-  await provisionBindings(cwd, options.logger, codegen.cronTriggers);
-  const validation = validateWranglerProject({ projectRoot: cwd });
-  if (validation.problems.length > 0) {
-    options.logger.error("wrangler.jsonc validation failed:");
-    for (const problem of validation.problems) {
-      options.logger.error(`  - ${problem}`);
-    }
-    return {
-      code: 1,
-      error: "wrangler validation failed",
-      validation
-    };
-  }
-  gate.rebless?.();
-  options.logger.success("project is ready to deploy");
-  return { code: 0, validation };
-};
-const execute = defineHandler(
-  ({ cwd, logger, options }) => runPrepareCommand({
-    allowSchemaDrift: options.allowSchemaDrift === true,
-    apiSpec: parseApiSpec(options.apiSpec),
-    cwd,
-    logger,
-    updateSchemaBaseline: options.updateSchemaBaseline === true
-  })
-);
+  logger.error("registry: unknown subcommand. Usage: lunora registry <add|list|view|build> [names…]");
+  return { code: 1 };
+});
 
-export { execute, runPrepareCommand };
+export { execute };

package/dist/packem_chunks/handler17.mjs

@@ -1,44 +1,105 @@
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { AGENT_RULES_DIR, detectAgentRules, LUNORA_SKILL_NAMES } from '@lunora/config';
+import { join, relative, dirname } from '@visulima/path';
 import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
-import { r as runAddCommand, b as runRegistryViewCommand, a as runBuildIndexCommand } from '../packem_shared/commands-D5Yxt9VY.mjs';
 
+const resolveBundledSkillsDirectory = (startDirectory = dirname(fileURLToPath(import.meta.url))) => {
+  let directory = startDirectory;
+  for (let index = 0; index < 6; index += 1) {
+    const packageJson = join(directory, "package.json");
+    if (existsSync(packageJson)) {
+      try {
+        const parsed = JSON.parse(readFileSync(packageJson, "utf8"));
+        if (parsed.name === "@lunora/cli") {
+          const skills = join(directory, "skills");
+          return existsSync(skills) ? skills : void 0;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+  return void 0;
+};
+const listBundledSkills = (skillsDirectory) => readdirSync(skillsDirectory).filter((name) => {
+  const directory = join(skillsDirectory, name);
+  return statSync(directory).isDirectory() && existsSync(join(directory, "SKILL.md"));
+});
+const copySkill = (source, destination, overwrite) => {
+  mkdirSync(destination, { recursive: true });
+  let wrote = false;
+  for (const entry of readdirSync(source)) {
+    const from = join(source, entry);
+    const to = join(destination, entry);
+    if (statSync(from).isDirectory()) {
+      wrote = copySkill(from, to, overwrite) || wrote;
+      continue;
+    }
+    if (existsSync(to) && !overwrite) {
+      continue;
+    }
+    writeFileSync(to, readFileSync(from));
+    wrote = true;
+  }
+  return wrote;
+};
+const runRulesInstall = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const overwrite = options.overwrite === true;
+  const skillsDirectory = resolveBundledSkillsDirectory();
+  if (skillsDirectory === void 0) {
+    options.logger.error("rules: could not locate the bundled skills (is @lunora/cli installed correctly?).");
+    return { code: 1, installed: [], skipped: [] };
+  }
+  const installed = [];
+  const skipped = [];
+  for (const name of listBundledSkills(skillsDirectory)) {
+    const destination = join(cwd, AGENT_RULES_DIR, name);
+    const wrote = copySkill(join(skillsDirectory, name), destination, overwrite);
+    if (wrote) {
+      installed.push(name);
+    } else {
+      skipped.push(name);
+    }
+  }
+  const target = relative(cwd, join(cwd, AGENT_RULES_DIR)) || AGENT_RULES_DIR;
+  if (installed.length > 0) {
+    options.logger.success(`Installed ${String(installed.length)} Lunora skill(s) into ${target}/: ${installed.join(", ")}.`);
+  }
+  if (skipped.length > 0) {
+    options.logger.info(`Skipped ${String(skipped.length)} existing skill(s) (re-run with --overwrite to replace): ${skipped.join(", ")}.`);
+  }
+  options.logger.info("Your AI coding agent will pick these up automatically. Start with the `lunora` skill.");
+  return { code: 0, installed, skipped };
+};
+const runRulesCheck = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const status = detectAgentRules(cwd);
+  if (status.installed) {
+    options.logger.success(`Lunora agent rules are installed (${String(status.present.length)}/${String(LUNORA_SKILL_NAMES.length)} skills).`);
+    if (status.missing.length > 0) {
+      options.logger.info(`Missing: ${status.missing.join(", ")}. Run \`lunora rules install\` to add them.`);
+    }
+    return { code: 0, installed: status.present, skipped: [] };
+  }
+  options.logger.warn("Lunora agent rules are not installed. Run `lunora rules install` so your AI agent knows how to use Lunora.");
+  return { code: options.strict === true ? 1 : 0, installed: status.present, skipped: [] };
+};
 const execute = defineHandler(({ argument, cwd, logger, options }) => {
-  const subcommand = argument[0];
-  const names = argument.slice(1);
-  if (subcommand === "add") {
-    return runAddCommand({
-      allowUnsafeSource: options.allowUnsafeSource === true,
-      cwd,
-      diff: options.diff === true,
-      dryRun: options.dryRun === true,
-      from: options.from,
-      json: options.json === true,
-      logger,
-      names,
-      overwrite: options.overwrite === true,
-      ref: options.ref,
-      source: options.source,
-      yes: options.yes === true
-    });
-  }
-  if (subcommand === "list") {
-    return runAddCommand({ cwd, from: options.from, json: options.json === true, list: true, logger, names: [], ref: options.ref, source: options.source });
-  }
-  if (subcommand === "view") {
-    return runRegistryViewCommand({
-      allowUnsafeSource: options.allowUnsafeSource === true,
-      cwd,
-      from: options.from,
-      logger,
-      names,
-      ref: options.ref,
-      source: options.source
-    });
-  }
-  if (subcommand === "build") {
-    return runBuildIndexCommand({ check: options.check === true, from: options.from, logger, out: options.out });
-  }
-  logger.error("registry: unknown subcommand. Usage: lunora registry <add|list|view|build> [names…]");
+  const subcommand = argument[0] ?? "check";
+  if (subcommand === "install") {
+    return runRulesInstall({ cwd, logger, overwrite: options.overwrite === true });
+  }
+  if (subcommand === "check") {
+    return runRulesCheck({ cwd, logger, strict: options.strict === true });
+  }
+  logger.error("rules: unknown subcommand. Usage: lunora rules <install|check>");
   return { code: 1 };
 });
 
-export { execute };
+export { execute, resolveBundledSkillsDirectory, runRulesCheck, runRulesInstall };