@corgelabs/corge 0.0.1 → 1.0.1

package/dist/bin/corge.js

@@ -0,0 +1,542 @@
+#!/usr/bin/env node
+
+// src/cli/builder.ts
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+var getCorgeRootDir = () => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  for (const candidate of [
+    resolve(currentDir, "../.."),
+    resolve(currentDir, "..")
+  ]) {
+    if (existsSync(join(candidate, "package.json")) && existsSync(join(candidate, "tsconfig.base.json"))) {
+      return candidate;
+    }
+  }
+  return resolve(currentDir, "../..");
+};
+var resolveCorgeEntrypoint = (cwd = process.cwd()) => {
+  try {
+    const req = createRequire(join(cwd, "package.json"));
+    return req.resolve("@corgelabs/corge");
+  } catch {
+    const root = getCorgeRootDir();
+    const distEntry = join(root, "dist/index.js");
+    return existsSync(distEntry) ? distEntry : join(root, "src/index.ts");
+  }
+};
+var resolveWithExtensions = (basePath) => {
+  for (const candidate of [
+    basePath,
+    `${basePath}.ts`,
+    `${basePath}.js`,
+    join(basePath, "index.ts"),
+    join(basePath, "index.js")
+  ]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+};
+var corgeAliasPlugin = (cwd = process.cwd()) => ({
+  name: "corge-alias",
+  setup(b) {
+    b.onResolve({ filter: /^(@core|@corgelabs\/corge)$/ }, () => ({
+      path: resolveCorgeEntrypoint(cwd),
+      external: false
+    }));
+    b.onResolve({ filter: /^@(config|routes|services|utils)\/(.+)$/ }, (args) => {
+      const match = /^@(config|routes|services|utils)\/(.+)$/.exec(args.path);
+      if (!match) return void 0;
+      const [, folder, rest2] = match;
+      const target = resolveWithExtensions(join(cwd, "src", folder, rest2));
+      if (target) return { path: target, external: false };
+      return void 0;
+    });
+    b.onResolve({ filter: /^@app-entry$/ }, () => {
+      const target = resolveWithExtensions(join(cwd, "src/index"));
+      if (target) return { path: target, external: false };
+      return { path: "corge-fallback-app", namespace: "corge-virtual" };
+    });
+    b.onLoad({ filter: /.*/, namespace: "corge-virtual" }, () => ({
+      contents: [
+        "import { core } from '@core'",
+        "export const { devApp, app, functions } = core.createApp({})"
+      ].join("\n"),
+      loader: "ts",
+      resolveDir: cwd
+    }));
+  }
+});
+var buildConsumerApp = async (cwd = process.cwd()) => {
+  await build({
+    absWorkingDir: cwd,
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    platform: "node",
+    target: "node24",
+    format: "cjs",
+    packages: "external",
+    plugins: [corgeAliasPlugin(cwd)],
+    footer: { js: "module.exports = functions;" },
+    outfile: "dist/index.cjs",
+    sourcemap: true
+  });
+};
+
+// src/cli/deployer.ts
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var mergeFirestoreIndexes = (base, custom) => {
+  const seenIndexes = /* @__PURE__ */ new Set();
+  const mergedIndexes = [];
+  for (const item of [...base.indexes ?? [], ...custom.indexes ?? []]) {
+    const key = JSON.stringify(item);
+    if (!seenIndexes.has(key)) {
+      seenIndexes.add(key);
+      mergedIndexes.push(item);
+    }
+  }
+  const seenOverrides = /* @__PURE__ */ new Set();
+  const mergedOverrides = [];
+  for (const item of [...base.fieldOverrides ?? [], ...custom.fieldOverrides ?? []]) {
+    const key = JSON.stringify(item);
+    if (!seenOverrides.has(key)) {
+      seenOverrides.add(key);
+      mergedOverrides.push(item);
+    }
+  }
+  return {
+    indexes: mergedIndexes,
+    fieldOverrides: mergedOverrides
+  };
+};
+var deployConsumerApp = async (target, cwd = process.cwd()) => {
+  try {
+    process.loadEnvFile(join2(cwd, ".env"));
+  } catch {
+  }
+  if (target !== "prod" && target !== "dev") {
+    console.error("Usage: corge deploy <prod|dev>");
+    process.exit(1);
+  }
+  const requiredBranch = target === "prod" ? "main" : "dev";
+  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8" }).trim();
+  if (currentBranch !== requiredBranch) {
+    console.error(
+      `Deploy blocked: "deploy ${target}" can only run on branch "${requiredBranch}" (current branch: "${currentBranch}").`
+    );
+    process.exit(1);
+  }
+  const project = process.env.GCP_PROJECT;
+  if (!project) {
+    console.error("Missing GCP_PROJECT in .env");
+    process.exit(1);
+  }
+  await buildConsumerApp(cwd);
+  const corgeRoot = getCorgeRootDir();
+  const firebaseJsonPath = join2(cwd, "firebase.json");
+  const pkgJsonPath = join2(cwd, "package.json");
+  const firestoreRulesPath = join2(cwd, "firestore.rules");
+  const firestoreIndexesPath = join2(cwd, "firestore.indexes.json");
+  const storageRulesPath = join2(cwd, "storage.rules");
+  const rawFirebaseJson = readFileSync(firebaseJsonPath, "utf8");
+  const rawPkgJson = readFileSync(pkgJsonPath, "utf8");
+  const hadFirestoreRules = existsSync2(firestoreRulesPath);
+  const rawFirestoreRules = hadFirestoreRules ? readFileSync(firestoreRulesPath, "utf8") : null;
+  const hadFirestoreIndexes = existsSync2(firestoreIndexesPath);
+  const rawFirestoreIndexes = hadFirestoreIndexes ? readFileSync(firestoreIndexesPath, "utf8") : null;
+  const hadStorageRules = existsSync2(storageRulesPath);
+  const rawStorageRules = hadStorageRules ? readFileSync(storageRulesPath, "utf8") : null;
+  const restoreFiles = () => {
+    try {
+      writeFileSync(firebaseJsonPath, rawFirebaseJson, "utf8");
+    } catch {
+    }
+    try {
+      writeFileSync(pkgJsonPath, rawPkgJson, "utf8");
+    } catch {
+    }
+    try {
+      if (hadFirestoreRules && rawFirestoreRules !== null) {
+        writeFileSync(firestoreRulesPath, rawFirestoreRules, "utf8");
+      } else if (!hadFirestoreRules && existsSync2(firestoreRulesPath)) {
+        unlinkSync(firestoreRulesPath);
+      }
+    } catch {
+    }
+    try {
+      if (hadFirestoreIndexes && rawFirestoreIndexes !== null) {
+        writeFileSync(firestoreIndexesPath, rawFirestoreIndexes, "utf8");
+      } else if (!hadFirestoreIndexes && existsSync2(firestoreIndexesPath)) {
+        unlinkSync(firestoreIndexesPath);
+      }
+    } catch {
+    }
+    try {
+      if (hadStorageRules && rawStorageRules !== null) {
+        writeFileSync(storageRulesPath, rawStorageRules, "utf8");
+      } else if (!hadStorageRules && existsSync2(storageRulesPath)) {
+        unlinkSync(storageRulesPath);
+      }
+    } catch {
+    }
+  };
+  process.once("SIGINT", () => {
+    restoreFiles();
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    restoreFiles();
+    process.exit(143);
+  });
+  try {
+    const baseFirestoreRules = readFileSync(join2(corgeRoot, "infra/firestore.base.rules"), "utf8");
+    const baseStorageRules = readFileSync(join2(corgeRoot, "infra/storage.base.rules"), "utf8");
+    const baseIndexes = JSON.parse(
+      readFileSync(join2(corgeRoot, "infra/firestore.base.indexes.json"), "utf8")
+    );
+    if (!hadFirestoreRules) {
+      writeFileSync(firestoreRulesPath, baseFirestoreRules, "utf8");
+    }
+    if (!hadStorageRules) {
+      writeFileSync(storageRulesPath, baseStorageRules, "utf8");
+    }
+    const customIndexes = hadFirestoreIndexes && rawFirestoreIndexes ? JSON.parse(rawFirestoreIndexes) : {};
+    const mergedIndexes = mergeFirestoreIndexes(baseIndexes, customIndexes);
+    writeFileSync(firestoreIndexesPath, JSON.stringify(mergedIndexes, null, 2) + "\n", "utf8");
+    const cfg = JSON.parse(rawFirebaseJson);
+    const prodDb = { database: project, rules: "firestore.rules", indexes: "firestore.indexes.json" };
+    const devDb = { database: `${project}-dev`, rules: "firestore.rules", indexes: "firestore.indexes.json" };
+    const prodBucket = { bucket: `${project}.firebasestorage.app`, rules: "storage.rules" };
+    const devBucket = { bucket: `${project}-dev`, rules: "storage.rules" };
+    cfg.firestore = target === "prod" ? [prodDb] : [devDb];
+    cfg.storage = target === "prod" ? [prodBucket] : [devBucket];
+    writeFileSync(firebaseJsonPath, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    const corgePkg = JSON.parse(readFileSync(join2(corgeRoot, "package.json"), "utf8"));
+    const consumerPkg = JSON.parse(rawPkgJson);
+    const expandedDeps = { ...corgePkg.dependencies ?? {}, ...consumerPkg.dependencies ?? {} };
+    delete expandedDeps["@corgelabs/corge"];
+    delete expandedDeps.esbuild;
+    consumerPkg.dependencies = expandedDeps;
+    writeFileSync(pkgJsonPath, JSON.stringify(consumerPkg, null, 2) + "\n", "utf8");
+    const onlyTargets = target === "prod" ? `functions:${project},functions:${project}-tasks,firestore:${project},storage` : `functions:${project}-dev,functions:${project}-tasks-dev,firestore:${project}-dev,storage`;
+    const deployRes = spawnSync(
+      "npx",
+      ["-y", "firebase-tools@latest", "deploy", "-P", project, "--only", onlyTargets],
+      { cwd, stdio: "inherit" }
+    );
+    process.exitCode = deployRes.status ?? 1;
+  } finally {
+    restoreFiles();
+  }
+};
+
+// src/cli/dev-server.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { join as join4 } from "node:path";
+import { context } from "esbuild";
+
+// src/cli/env.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { parseEnv } from "node:util";
+import { applicationDefault } from "firebase-admin/app";
+var hasValue = (value) => value != null && value.length > 0;
+var readDotEnv = (cwd = process.cwd()) => {
+  const envPath = join3(cwd, ".env");
+  return existsSync3(envPath) ? parseEnv(readFileSync2(envPath, "utf8")) : {};
+};
+var getSecretText = async (projectId, accessToken, secretName) => {
+  const url = `https://secretmanager.googleapis.com/v1/projects/${projectId}/secrets/${secretName}/versions/latest:access`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${accessToken}` } });
+  const data = await res.json();
+  if (!res.ok || !data.payload?.data) {
+    throw new Error(`Secret is empty or not defined: ${secretName} (${data.error?.message ?? res.status})`);
+  }
+  return Buffer.from(data.payload.data, "base64").toString("utf8");
+};
+var getSecrets = async (secretNames, cwd = process.cwd()) => {
+  const dotEnv = readDotEnv(cwd);
+  const merged = {};
+  for (const [key, value] of Object.entries(dotEnv)) {
+    if (hasValue(process.env[key])) {
+      merged[key] = process.env[key];
+    } else if (hasValue(value)) {
+      merged[key] = value;
+    }
+  }
+  const projectId = merged.GCP_PROJECT || process.env.GCP_PROJECT;
+  const keysToResolve = secretNames && secretNames.length > 0 ? secretNames.filter((name) => !hasValue(merged[name]) && !hasValue(process.env[name])) : Object.entries(dotEnv).filter(([key, value]) => !hasValue(value) && !hasValue(process.env[key])).map(([key]) => key);
+  if (keysToResolve.length > 0 && projectId) {
+    const { access_token } = await applicationDefault().getAccessToken();
+    if (!access_token) throw new Error("Failed to obtain GCP Application Default Credentials access token");
+    const resolved = await Promise.all(
+      keysToResolve.map(
+        async (secretName) => [secretName, await getSecretText(projectId, access_token, secretName)]
+      )
+    );
+    for (const [key, value] of resolved) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+};
+var loadGcpSecrets = async (secretNames, cwd = process.cwd()) => {
+  const env = await getSecrets(secretNames, cwd);
+  for (const [k, v] of Object.entries(env)) {
+    if (!hasValue(process.env[k])) process.env[k] = v;
+  }
+  return env;
+};
+var runWithGcpEnv = async (cmd, secretNames, cwd = process.cwd()) => {
+  const env = await getSecrets(secretNames, cwd);
+  return new Promise((resolve3, reject) => {
+    const child = spawn(cmd[0], cmd.slice(1), {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve3(code ?? 1));
+  });
+};
+
+// src/cli/dev-server.ts
+var devBootstrapPlugin = (cwd) => ({
+  name: "corge-dev-bootstrap",
+  setup(b) {
+    b.onResolve({ filter: /^virtual:corge-dev-entry$/ }, () => ({
+      path: "virtual:corge-dev-entry",
+      namespace: "corge-dev"
+    }));
+    b.onLoad({ filter: /^virtual:corge-dev-entry$/, namespace: "corge-dev" }, () => ({
+      contents: [
+        "import { EventEmitter } from 'node:events'",
+        "import { serve } from '@hono/node-server'",
+        "import { devApp } from './src/index'",
+        "EventEmitter.defaultMaxListeners = 100",
+        "const port = Number(process.env.PORT ?? 8080)",
+        "serve({ fetch: devApp.fetch, port })"
+      ].join("\n"),
+      loader: "ts",
+      resolveDir: cwd
+    }));
+  }
+});
+var runDevServer = async (cwd = process.cwd()) => {
+  await loadGcpSecrets(void 0, cwd);
+  const outDir = join4(cwd, ".corge");
+  mkdirSync(outDir, { recursive: true });
+  const outFile = join4(outDir, "dev.js");
+  const ctx = await context({
+    absWorkingDir: cwd,
+    entryPoints: ["virtual:corge-dev-entry"],
+    bundle: true,
+    platform: "node",
+    target: "node24",
+    format: "esm",
+    packages: "external",
+    plugins: [devBootstrapPlugin(cwd), corgeAliasPlugin(cwd)],
+    outfile: outFile,
+    sourcemap: true
+  });
+  await ctx.watch();
+  const child = spawn2(process.execPath, ["--watch", outFile], {
+    cwd,
+    env: process.env,
+    stdio: "inherit"
+  });
+  const cleanup = async (code) => {
+    try {
+      child.kill("SIGTERM");
+      await ctx.dispose();
+    } catch {
+    }
+    process.exit(code);
+  };
+  process.once("SIGINT", () => void cleanup(130));
+  process.once("SIGTERM", () => void cleanup(143));
+  await new Promise((resolve3, reject) => {
+    child.on("error", reject);
+    child.on("close", async (code) => {
+      await ctx.dispose();
+      process.exitCode = code ?? 0;
+      resolve3();
+    });
+  });
+};
+
+// src/cli/init.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join5, resolve as resolve2 } from "node:path";
+import { build as build2 } from "esbuild";
+var runTypeCheck = (cwd = process.cwd()) => {
+  const res = spawnSync2("npx", ["tsc", "--noEmit"], { cwd, stdio: "inherit" });
+  process.exitCode = res.status ?? 1;
+};
+var runTestSuite = async (cwd = process.cwd()) => {
+  await loadGcpSecrets(void 0, cwd);
+  const corgeRoot = getCorgeRootDir();
+  const outDir = join5(cwd, ".corge");
+  mkdirSync2(outDir, { recursive: true });
+  const outFile = join5(outDir, "test.js");
+  const localTest = join5(cwd, "tests/e2e.test.ts");
+  const resolvedEntry = existsSync4(localTest) ? localTest : join5(corgeRoot, "tests/e2e.test.ts");
+  await build2({
+    absWorkingDir: cwd,
+    entryPoints: [resolvedEntry],
+    bundle: true,
+    platform: "node",
+    target: "node24",
+    format: "esm",
+    packages: "external",
+    plugins: [corgeAliasPlugin(cwd)],
+    outfile: outFile,
+    sourcemap: true
+  });
+  const res = spawnSync2(process.execPath, ["--test", outFile], {
+    cwd,
+    env: process.env,
+    stdio: "inherit"
+  });
+  process.exitCode = res.status ?? 1;
+};
+var linkCorge = (targetPath = "/Users/nikdelvin/corgelabs/corge", cwd = process.cwd()) => {
+  const resolvedTarget = resolve2(cwd, targetPath);
+  const linkDest = join5(cwd, "node_modules/@corgelabs/corge");
+  mkdirSync2(dirname2(linkDest), { recursive: true });
+  rmSync(linkDest, { recursive: true, force: true });
+  symlinkSync(resolvedTarget, linkDest, "dir");
+  console.log(`Linked ${linkDest} -> ${resolvedTarget}`);
+};
+var unlinkCorge = (cwd = process.cwd()) => {
+  const linkDest = join5(cwd, "node_modules/@corgelabs/corge");
+  rmSync(linkDest, { recursive: true, force: true });
+  const res = spawnSync2("npm", ["install", "@corgelabs/corge@latest"], { cwd, stdio: "inherit" });
+  process.exitCode = res.status ?? 1;
+};
+var initConsumerProject = (cwd = process.cwd()) => {
+  mkdirSync2(join5(cwd, "src/config"), { recursive: true });
+  mkdirSync2(join5(cwd, "src/routes"), { recursive: true });
+  mkdirSync2(join5(cwd, "src/services"), { recursive: true });
+  mkdirSync2(join5(cwd, "src/context"), { recursive: true });
+  const writeIfMissing = (relPath, content) => {
+    const full = join5(cwd, relPath);
+    if (!existsSync4(full)) {
+      writeFileSync2(full, content, "utf8");
+      console.log(`Created ${relPath}`);
+    }
+  };
+  writeIfMissing(
+    "tsconfig.json",
+    JSON.stringify(
+      {
+        extends: "@corgelabs/corge/tsconfig.base.json",
+        compilerOptions: {
+          paths: {
+            "@core": ["./node_modules/@corgelabs/corge/dist/index.d.ts"],
+            "@routes/*": ["./src/routes/*"],
+            "@services/*": ["./src/services/*"],
+            "@utils/*": ["./src/utils/*"],
+            "@config/*": ["./src/config/*"]
+          }
+        },
+        include: ["src/**/*.ts"]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  writeIfMissing(
+    "src/index.ts",
+    [
+      "import { core } from '@core'",
+      "",
+      "export const coreApp = core.createApp({})",
+      "",
+      "export const {",
+      "  createApp,",
+      "  app,",
+      "  devApp,",
+      "  workflowRegistry,",
+      "  httpHandler,",
+      "  devHttpHandler,",
+      "  tasksHandler,",
+      "  devTasksHandler,",
+      "  functions",
+      "} = coreApp",
+      ""
+    ].join("\n")
+  );
+  writeIfMissing(
+    ".gitignore",
+    ["node_modules/", "dist/", ".corge/", ".env", "*.local", "firebase-debug.log", ".DS_Store", ""].join("\n")
+  );
+};
+
+// bin/corge.ts
+var [command, ...rest] = process.argv.slice(2);
+switch (command) {
+  case "dev":
+    await runDevServer();
+    break;
+  case "build":
+    await buildConsumerApp();
+    break;
+  case "deploy":
+    await deployConsumerApp(rest[0]);
+    break;
+  case "test":
+    await runTestSuite();
+    break;
+  case "check":
+    runTypeCheck();
+    break;
+  case "init":
+    initConsumerProject();
+    break;
+  case "link":
+    linkCorge(rest[0]);
+    break;
+  case "unlink":
+    unlinkCorge();
+    break;
+  case "env": {
+    const sep = rest.indexOf("--");
+    const secrets = sep === -1 ? [] : rest.slice(0, sep);
+    const cmd = sep === -1 ? rest : rest.slice(sep + 1);
+    if (cmd.length === 0) {
+      console.error("Usage: corge env [SECRET_NAMES...] -- <command...>");
+      process.exit(1);
+    }
+    process.exit(await runWithGcpEnv(cmd, secrets));
+    break;
+  }
+  default:
+    console.log(
+      [
+        "Corge CLI (@corgelabs/corge)",
+        "",
+        "Commands:",
+        "  corge dev                  Start local Hono dev server with GCP Secret Manager + watch mode",
+        "  corge build                Bundle src/index.ts + @corgelabs/corge into dist/index.cjs",
+        "  corge deploy <prod|dev>    Build, merge base rules/indexes, and deploy to Firebase",
+        "  corge test                 Bundle and execute E2E contract test suite",
+        "  corge check                Run tsc --noEmit in workspace",
+        "  corge init                 Scaffold consumer project structure",
+        "  corge link [path]          Link local corgelabs/corge checkout into node_modules",
+        "  corge unlink               Restore published @corgelabs/corge from npm"
+      ].join("\n")
+    );
+    if (command && command !== "--help" && command !== "-h") {
+      process.exit(1);
+    }
+}

package/dist/chat/context.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '../index';
+import type { ContextEntry, ContextItemSpec, GetContextOptions, HybridRetrievalOptions, HybridRetrievalResult } from './schema';
+export declare class ChatContextEngine {
+    #private;
+    constructor(coreClient: Core);
+    registerContextCatalog: (items?: readonly ContextItemSpec[], reset?: boolean) => void;
+    getContext: (prompt: string, catalog?: readonly ContextItemSpec[], options?: GetContextOptions) => Promise<ContextEntry[]>;
+    retrieveContext: (opts: HybridRetrievalOptions) => Promise<HybridRetrievalResult>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/chat/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/chat/context.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAC/B,OAAO,KAAK,EAIV,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EAItB,MAAM,UAAU,CAAA;AAajB,qBAAa,iBAAiB;;IAG5B,YAAY,UAAU,EAAE,IAAI,EAE3B;IAED,sBAAsB,WAAW,SAAS,eAAe,EAAE,sBAAuB,IAAI,CAMrF;IAqBD,UAAU,WACA,MAAM,YACL,SAAS,eAAe,EAAE,YACzB,iBAAiB,KAC1B,OAAO,CAAC,YAAY,EAAE,CAAC,CAsDzB;IA8GD,eAAe,SAAgB,sBAAsB,KAAG,OAAO,CAAC,qBAAqB,CAAC,CAyErF;CACF"}