gorsee 0.2.4 → 0.2.5

package/dist-pkg/cli/canonical-imports.js

@@ -0,0 +1,131 @@
+export const SERVER_SCOPED_IMPORTS = new Map([
+  ["createAuth", "gorsee/auth"],
+  ["createMemorySessionStore", "gorsee/auth"],
+  ["createNamespacedSessionStore", "gorsee/auth"],
+  ["createRedisSessionStore", "gorsee/auth"],
+  ["createSQLiteSessionStore", "gorsee/auth"],
+  ["createAuthActionTokenManager", "gorsee/auth"],
+  ["createMemoryAuthActionTokenStore", "gorsee/auth"],
+  ["sessionHasRole", "gorsee/auth"],
+  ["sessionHasPermission", "gorsee/auth"],
+  ["AuthConfig", "gorsee/auth"],
+  ["AuthEvent", "gorsee/auth"],
+  ["AuthEventHandler", "gorsee/auth"],
+  ["AuthActionTokenClaims", "gorsee/auth"],
+  ["AuthActionTokenPurpose", "gorsee/auth"],
+  ["AuthActionTokenReplayStore", "gorsee/auth"],
+  ["PermissionResolver", "gorsee/auth"],
+  ["Session", "gorsee/auth"],
+  ["SessionStore", "gorsee/auth"],
+  ["createDB", "gorsee/db"],
+  ["createPostgresDB", "gorsee/db"],
+  ["toPostgresSQL", "gorsee/db"],
+  ["runMigrations", "gorsee/db"],
+  ["createMigration", "gorsee/db"],
+  ["DB", "gorsee/db"],
+  ["PostgresDB", "gorsee/db"],
+  ["PostgresClientLike", "gorsee/db"],
+  ["PostgresConnectionLike", "gorsee/db"],
+  ["PostgresPoolLike", "gorsee/db"],
+  ["PostgresQueryResult", "gorsee/db"],
+  ["MigrationResult", "gorsee/db"],
+  ["securityHeaders", "gorsee/security"],
+  ["csrfProtection", "gorsee/security"],
+  ["createCSRFMiddleware", "gorsee/security"],
+  ["generateCSRFToken", "gorsee/security"],
+  ["validateCSRFToken", "gorsee/security"],
+  ["createRateLimiter", "gorsee/security"],
+  ["createRedisRateLimiter", "gorsee/security"],
+  ["parseRateLimitWindow", "gorsee/security"],
+  ["cors", "gorsee/security"],
+  ["SecurityConfig", "gorsee/security"],
+  ["RateLimiter", "gorsee/security"],
+  ["AsyncRateLimiter", "gorsee/security"],
+  ["AsyncRateLimitResult", "gorsee/security"],
+  ["CORSOptions", "gorsee/security"],
+  ["env", "gorsee/env"],
+  ["getPublicEnv", "gorsee/env"],
+  ["loadEnv", "gorsee/env"],
+  ["log", "gorsee/log"],
+  ["setLogLevel", "gorsee/log"],
+  ["setupI18n", "gorsee/i18n"],
+  ["loadLocale", "gorsee/i18n"],
+  ["getLocale", "gorsee/i18n"],
+  ["getLocales", "gorsee/i18n"],
+  ["getDefaultLocale", "gorsee/i18n"],
+  ["getFallbackLocales", "gorsee/i18n"],
+  ["setLocale", "gorsee/i18n"],
+  ["t", "gorsee/i18n"],
+  ["plural", "gorsee/i18n"],
+  ["negotiateLocale", "gorsee/i18n"],
+  ["resolveLocaleFromPath", "gorsee/i18n"],
+  ["stripLocalePrefix", "gorsee/i18n"],
+  ["withLocalePath", "gorsee/i18n"],
+  ["buildHreflangLinks", "gorsee/i18n"],
+  ["formatNumber", "gorsee/i18n"],
+  ["formatDate", "gorsee/i18n"],
+  ["formatRelativeTime", "gorsee/i18n"],
+  ["I18nConfig", "gorsee/i18n"],
+  ["LocaleNegotiationInput", "gorsee/i18n"],
+  ["LocaleNegotiationResult", "gorsee/i18n"],
+  ["loadContentCollection", "gorsee/content"],
+  ["parseFrontmatter", "gorsee/content"],
+  ["extractExcerpt", "gorsee/content"],
+  ["queryContent", "gorsee/content"],
+  ["getContentEntryBySlug", "gorsee/content"],
+  ["ContentCollectionOptions", "gorsee/content"],
+  ["ContentEntry", "gorsee/content"],
+  ["ContentQueryOptions", "gorsee/content"]
+]), CLIENT_SCOPED_IMPORTS = new Map([
+  ["defineForm", "gorsee/forms"],
+  ["defineFormAction", "gorsee/forms"],
+  ["validateForm", "gorsee/forms"],
+  ["validateAction", "gorsee/forms"],
+  ["toFieldErrors", "gorsee/forms"],
+  ["fieldAttrs", "gorsee/forms"],
+  ["actionSuccess", "gorsee/forms"],
+  ["actionFailure", "gorsee/forms"],
+  ["FormField", "gorsee/forms"],
+  ["FormSchema", "gorsee/forms"],
+  ["ValidationResult", "gorsee/forms"],
+  ["ActionValidationResult", "gorsee/forms"],
+  ["ValidationError", "gorsee/forms"],
+  ["DefineFormActionOptions", "gorsee/forms"],
+  ["FormActionContext", "gorsee/forms"],
+  ["ActionResult", "gorsee/forms"],
+  ["typedLink", "gorsee/routes"],
+  ["typedNavigate", "gorsee/routes"],
+  ["typedPrefetch", "gorsee/routes"],
+  ["resolveTypedRouteTarget", "gorsee/routes"],
+  ["buildSearchParams", "gorsee/routes"],
+  ["buildTypedPath", "gorsee/routes"],
+  ["createTypedRoute", "gorsee/routes"],
+  ["extractRouteParamKeys", "gorsee/routes"],
+  ["TypedRouteDefinition", "gorsee/routes"],
+  ["TypedRouteTarget", "gorsee/routes"]
+]);
+export function collectCanonicalImportDrift(imports) {
+  const drift = [];
+  for (const entry of imports) {
+    if (entry.specifier === "gorsee/server") {
+      const replacements = collectScopedReplacements(entry, SERVER_SCOPED_IMPORTS);
+      if (replacements.size > 0)
+        drift.push({ source: "gorsee/server", replacements });
+    }
+    if (entry.specifier === "gorsee/client") {
+      const replacements = collectScopedReplacements(entry, CLIENT_SCOPED_IMPORTS);
+      if (replacements.size > 0)
+        drift.push({ source: "gorsee/client", replacements });
+    }
+  }
+  return drift;
+}
+function collectScopedReplacements(entry, scopedMap) {
+  const replacements = new Map;
+  for (const name of entry.names) {
+    const target = scopedMap.get(name);
+    if (target)
+      replacements.set(name, target);
+  }
+  return replacements;
+}

package/dist-pkg/cli/check-ast.d.ts

@@ -0,0 +1,20 @@
+import { type ModuleImportFact } from "../compiler/module-analysis.js";
+export interface ASTCheckIssue {
+    code: string;
+    file: string;
+    line?: number;
+    message: string;
+    fix?: string;
+}
+export interface ASTFileFacts {
+    issues: ASTCheckIssue[];
+    hasServerCall: boolean;
+    hasRouteCacheCall: boolean;
+    hasCreateAuthCall: boolean;
+    hasRedirectCall: boolean;
+    hasCtxRedirectCall: boolean;
+    hasLegacyLoaderExport: boolean;
+    importsRootGorsee: boolean;
+    imports: ModuleImportFact[];
+}
+export declare function analyzeFileWithAST(file: string, cwd: string, content: string): Promise<ASTFileFacts | null>;

package/dist-pkg/cli/check-ast.js

@@ -0,0 +1,126 @@
+import { relative } from "node:path";
+import { analyzeModuleSource } from "../compiler/module-analysis.js";
+let tsModulePromise = null;
+async function loadTypeScript() {
+  if (!tsModulePromise)
+    tsModulePromise = import("typescript").catch(() => null);
+  return tsModulePromise;
+}
+function pushIssue(issues, seen, issue) {
+  const key = `${issue.code}:${issue.file}:${issue.line ?? 0}:${issue.message}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  issues.push(issue);
+}
+function isIdentifier(ts, node, name) {
+  return ts.isIdentifier(node) && node.text === name;
+}
+function getLine(ts, sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function isLiteralRedirectTarget(ts, node) {
+  if (!node)
+    return !1;
+  if (ts.isStringLiteralLike(node))
+    return !0;
+  if (ts.isNoSubstitutionTemplateLiteral(node))
+    return !0;
+  return !1;
+}
+function isDbCall(ts, expr) {
+  if (!ts.isPropertyAccessExpression(expr.expression))
+    return !1;
+  const target = expr.expression.expression, method = expr.expression.name.text;
+  return isIdentifier(ts, target, "db") && ["get", "all", "run"].includes(method);
+}
+function hasRouteCacheIntent(ts, expr) {
+  const firstArg = expr.arguments[0];
+  if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+    return !1;
+  return firstArg.properties.some((prop) => {
+    if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop))
+      return !1;
+    const name = prop.name?.getText(firstArg.getSourceFile()).replace(/['"]/g, "");
+    return name === "includeAuthHeaders" || name === "vary" || name === "key" || name === "mode";
+  });
+}
+export async function analyzeFileWithAST(file, cwd, content) {
+  const ts = await loadTypeScript();
+  if (!ts)
+    return null;
+  const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, !0, ts.ScriptKind.TSX), moduleFacts = analyzeModuleSource(file, content), rel = relative(cwd, file), issues = [], seen = new Set, facts = {
+    issues,
+    hasServerCall: !1,
+    hasRouteCacheCall: !1,
+    hasCreateAuthCall: !1,
+    hasRedirectCall: !1,
+    hasCtxRedirectCall: !1,
+    hasLegacyLoaderExport: moduleFacts.exportedNames.has("loader"),
+    importsRootGorsee: moduleFacts.imports.some((entry) => entry.specifier === "gorsee"),
+    imports: moduleFacts.imports
+  }, visit = (node) => {
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.name.text === "innerHTML")
+      pushIssue(issues, seen, {
+        code: "E002",
+        file: rel,
+        line: getLine(ts, sourceFile, node),
+        message: "Direct innerHTML assignment (XSS risk)",
+        fix: "Use SafeHTML`...`, sanitize(), or DOM fragment replacement helpers"
+      });
+    if (ts.isCallExpression(node)) {
+      if (isIdentifier(ts, node.expression, "server"))
+        facts.hasServerCall = !0;
+      if (isIdentifier(ts, node.expression, "createAuth"))
+        facts.hasCreateAuthCall = !0;
+      if (isIdentifier(ts, node.expression, "routeCache")) {
+        facts.hasRouteCacheCall = !0;
+        if (!hasRouteCacheIntent(ts, node))
+          pushIssue(issues, seen, {
+            code: "W904",
+            file: rel,
+            line: getLine(ts, sourceFile, node),
+            message: "routeCache() is used without explicit public/private cache intent",
+            fix: "Set includeAuthHeaders, vary, key, or mode explicitly to document cache boundary"
+          });
+      }
+      if (isIdentifier(ts, node.expression, "redirect")) {
+        facts.hasRedirectCall = !0;
+        if (!isLiteralRedirectTarget(ts, node.arguments[0]))
+          pushIssue(issues, seen, {
+            code: "W905",
+            file: rel,
+            line: getLine(ts, sourceFile, node),
+            message: "Throwable redirect() uses a non-literal target",
+            fix: "Prefer ctx.redirect() for user-controlled values or sanitize redirect targets explicitly before throwing redirect()"
+          });
+      }
+      if (ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "ctx" && node.expression.name.text === "redirect")
+        facts.hasCtxRedirectCall = !0;
+      if (isDbCall(ts, node)) {
+        const firstArg = node.arguments[0];
+        if (firstArg) {
+          if (ts.isNoSubstitutionTemplateLiteral(firstArg) || ts.isTemplateExpression(firstArg))
+            pushIssue(issues, seen, {
+              code: "E001",
+              file: rel,
+              line: getLine(ts, sourceFile, node),
+              message: "Raw template literal in database query (SQL injection risk)",
+              fix: "Use SafeSQL`...` tagged template: db.get(SafeSQL`SELECT ...`)"
+            });
+          else if (ts.isStringLiteral(firstArg) || ts.isBinaryExpression(firstArg))
+            pushIssue(issues, seen, {
+              code: "E001",
+              file: rel,
+              line: getLine(ts, sourceFile, node),
+              message: "String concatenation in database query (SQL injection risk)",
+              fix: "Use SafeSQL`...` tagged template with parameterized values"
+            });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return facts;
+}

package/dist-pkg/cli/cmd-ai.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeOptions } from "../runtime/project.js";
+export interface AICommandOptions extends RuntimeOptions {
+}
+export declare function runAI(args: string[], options?: AICommandOptions): Promise<void>;

package/dist-pkg/cli/cmd-ai.js

@@ -0,0 +1,290 @@
+import { createProjectContext } from "../runtime/project.js";
+import {
+  buildAIHealthReport,
+  buildAIContextBundle,
+  buildIDEProjection,
+  createIDEProjectionWatcher,
+  createAIBridgeServer,
+  createAIContextPacket,
+  createAIMCPServer,
+  createLineReader,
+  readAIDiagnosticsSnapshot,
+  readAIEvents,
+  readReactiveTraceArtifact,
+  renderAIContextMarkdown,
+  renderAIContextBundleMarkdown,
+  resolveAIStorePaths,
+  resolveAISessionPackPaths,
+  resolveIDEProjectionPaths,
+  writeAISessionPack,
+  writeIDEProjection
+} from "../ai/index.js";
+export async function runAI(args, options = {}) {
+  const subcommand = args[0] ?? "help", flags = parseAIFlags(args.slice(1)), { cwd } = createProjectContext(options), paths = resolveAIStorePaths(cwd);
+  switch (subcommand) {
+    case "tail":
+      return runAITail(paths.eventsPath, flags);
+    case "doctor":
+      return runAIDoctor(paths, flags);
+    case "replay":
+      return runAIReplay(paths.eventsPath, flags);
+    case "export":
+      return runAIExport(cwd, paths, flags);
+    case "pack":
+      return runAIPack(cwd, paths, flags);
+    case "ide-sync":
+      return runAIIDESync(cwd, paths, flags);
+    case "bridge":
+      return runAIBridge(paths.eventsPath, flags);
+    case "mcp":
+      return runAIMCP(paths, flags);
+    case "help":
+    default:
+      printAIHelp();
+  }
+}
+async function runAITail(eventsPath, flags) {
+  const events = await readAIEvents(eventsPath, { limit: flags.limit ?? 20 });
+  if (flags.json) {
+    console.log(JSON.stringify(events, null, 2));
+    return;
+  }
+  if (events.length === 0) {
+    console.log(`
+  No AI events found.
+`);
+    return;
+  }
+  console.log();
+  for (const event of events) {
+    const loc = [event.route, event.file && event.line ? `${event.file}:${event.line}` : event.file].filter(Boolean).join(" ");
+    console.log(`  [${event.severity}] ${event.kind} ${event.message}`);
+    console.log(`    ${event.ts}${loc ? `  ${loc}` : ""}`);
+  }
+  console.log();
+}
+async function runAIDoctor(paths, flags) {
+  const report = await buildAIHealthReport(paths, { limit: flags.limit ?? 200 }), reactiveTrace = await readReactiveTraceArtifact(paths.reactiveTracePath);
+  if (flags.json) {
+    console.log(JSON.stringify({
+      ...report,
+      reactiveTrace: reactiveTrace ? {
+        schemaVersion: reactiveTrace.schemaVersion,
+        nodes: reactiveTrace.nodes.length,
+        edges: reactiveTrace.edges.length,
+        events: reactiveTrace.events.length,
+        latestEventKind: reactiveTrace.events.at(-1)?.kind
+      } : null
+    }, null, 2));
+    return;
+  }
+  console.log(`
+  Gorsee AI Doctor
+`);
+  console.log(`  Events: ${report.events.total}`);
+  console.log(`  Diagnostics: ${report.diagnostics.total}`);
+  console.log(`  Errors: ${report.diagnostics.errors}`);
+  console.log(`  Warnings: ${report.diagnostics.warnings}`);
+  if (report.events.latest)
+    console.log(`  Latest event: ${report.events.latest.kind} @ ${report.events.latest.ts}`);
+  if (report.diagnostics.latest?.code)
+    console.log(`  Latest diagnostic: ${report.diagnostics.latest.code} ${report.diagnostics.latest.message ?? ""}`.trim());
+  if (report.incidents.length > 0) {
+    console.log(`
+  Recent incidents:`);
+    for (const incident of report.incidents.slice(0, 5)) {
+      const loc = incident.file ? ` (${incident.file}${incident.line ? `:${incident.line}` : ""})` : incident.route ? ` (${incident.route})` : "";
+      console.log(`    - [${incident.kind}] ${incident.message}${loc}`);
+    }
+  }
+  if (report.incidentClusters.length > 0) {
+    console.log(`
+  Incident clusters:`);
+    for (const cluster of report.incidentClusters.slice(0, 5)) {
+      const loc = cluster.file ? ` (${cluster.file})` : cluster.route ? ` (${cluster.route})` : "";
+      console.log(`    - [${cluster.kind}] x${cluster.count}${loc}`);
+    }
+  }
+  if (report.artifactRegressions.length > 0) {
+    console.log(`
+  Artifact regressions:`);
+    for (const artifact of report.artifactRegressions.slice(0, 5)) {
+      const details = [artifact.version, artifact.path].filter(Boolean).join(" ");
+      console.log(`    - [${artifact.phase}] errors=${artifact.errors} warnings=${artifact.warnings} successes=${artifact.successes}${details ? ` (${details})` : ""}`);
+    }
+  }
+  if (reactiveTrace) {
+    console.log(`
+  Reactive trace:`);
+    console.log(`    - schema=${reactiveTrace.schemaVersion} nodes=${reactiveTrace.nodes.length} edges=${reactiveTrace.edges.length} events=${reactiveTrace.events.length}`);
+    if (reactiveTrace.events.at(-1)?.kind)
+      console.log(`    - latest=${reactiveTrace.events.at(-1)?.kind}`);
+  }
+  console.log();
+}
+async function runAIReplay(eventsPath, flags) {
+  const events = await readAIEvents(eventsPath, { limit: flags.limit ?? 50 });
+  if (events.length === 0) {
+    console.log(`
+  No AI events found.
+`);
+    return;
+  }
+  console.log(`
+  Gorsee AI Replay
+`);
+  for (const event of events) {
+    const trace = [event.requestId, event.traceId, event.spanId].filter(Boolean).join(" / "), loc = [event.route, event.file && event.line ? `${event.file}:${event.line}` : event.file].filter(Boolean).join(" "), artifact = typeof event.data?.artifact === "string" ? event.data.artifact : void 0, version = typeof event.data?.version === "string" ? event.data.version : void 0;
+    console.log(`  ${event.ts}  [${event.severity}] ${event.kind}`);
+    console.log(`    ${event.message}`);
+    if (trace)
+      console.log(`    trace: ${trace}`);
+    if (loc)
+      console.log(`    loc:   ${loc}`);
+    if (version || artifact)
+      console.log(`    data:  ${[version, artifact].filter(Boolean).join("  ")}`);
+  }
+  console.log();
+}
+async function runAIExport(cwd, paths, flags) {
+  if (flags.bundle) {
+    const bundle = await buildAIContextBundle(cwd, paths, { limit: flags.limit ?? 200 });
+    if ((flags.format ?? "json") === "markdown") {
+      console.log(renderAIContextBundleMarkdown(bundle));
+      return;
+    }
+    console.log(JSON.stringify(bundle, null, 2));
+    return;
+  }
+  const events = await readAIEvents(paths.eventsPath, { limit: flags.limit ?? 200 }), diagnostics = await readAIDiagnosticsSnapshot(paths.diagnosticsPath), reactiveTrace = await readReactiveTraceArtifact(paths.reactiveTracePath), report = await buildAIHealthReport(paths, { limit: flags.limit ?? 200 }), packet = createAIContextPacket(report, events, diagnostics?.latest, reactiveTrace);
+  if ((flags.format ?? "json") === "markdown") {
+    console.log(renderAIContextMarkdown(packet));
+    return;
+  }
+  console.log(JSON.stringify(packet, null, 2));
+}
+async function runAIPack(cwd, paths, flags) {
+  const result = await writeAISessionPack(cwd, paths, {
+    enabled: !0,
+    outDir: resolveAISessionPackPaths(cwd).outDir,
+    limit: flags.limit ?? 200
+  });
+  if (flags.json) {
+    console.log(JSON.stringify({
+      generatedAt: result.bundle.generatedAt,
+      latestJsonPath: result.paths.latestJsonPath,
+      latestMarkdownPath: result.paths.latestMarkdownPath,
+      historyDir: result.paths.historyDir,
+      snippets: result.bundle.snippets.length
+    }, null, 2));
+    return;
+  }
+  console.log(`
+  Gorsee AI Session Pack
+`);
+  console.log(`  latest json -> ${result.paths.latestJsonPath}`);
+  console.log(`  latest md   -> ${result.paths.latestMarkdownPath}`);
+  console.log(`  history     -> ${result.paths.historyDir}`);
+  console.log(`  snippets    -> ${result.bundle.snippets.length}`);
+  console.log();
+}
+async function runAIIDESync(cwd, paths, flags) {
+  const projection = await buildIDEProjection(paths, { limit: flags.limit ?? 100 }), projectionPaths = resolveIDEProjectionPaths(cwd);
+  await writeIDEProjection(projectionPaths, projection);
+  if (flags.watch) {
+    createIDEProjectionWatcher({
+      storePaths: paths,
+      projectionPaths,
+      limit: flags.limit ?? 100,
+      intervalMs: flags.intervalMs ?? 1000
+    }).start();
+    console.log(`
+  Gorsee AI IDE Sync --watch
+`);
+    console.log(`  diagnostics -> ${projectionPaths.diagnosticsPath}`);
+    console.log(`  events      -> ${projectionPaths.eventsPath}`);
+    console.log(`  context     -> ${projectionPaths.contextPath}`);
+    console.log(`  interval    -> ${flags.intervalMs ?? 1000}ms`);
+    console.log();
+    await new Promise(() => {});
+  }
+  if (flags.json) {
+    console.log(JSON.stringify({ projectionPaths, diagnostics: projection.diagnostics.length, events: projection.recentEvents.length }, null, 2));
+    return;
+  }
+  console.log(`
+  Gorsee AI IDE Sync
+`);
+  console.log(`  diagnostics -> ${projectionPaths.diagnosticsPath}`);
+  console.log(`  events      -> ${projectionPaths.eventsPath}`);
+  console.log(`  context     -> ${projectionPaths.contextPath}`);
+  console.log();
+}
+async function runAIBridge(eventsPath, flags) {
+  const bridge = createAIBridgeServer({
+    port: flags.port ?? 4318,
+    host: flags.host ?? "127.0.0.1",
+    persistPath: flags.persistPath ?? eventsPath
+  });
+  console.log(`
+  Gorsee AI bridge listening on http://${flags.host ?? "127.0.0.1"}:${bridge.port}/gorsee/ai-events
+`);
+  await new Promise(() => {});
+}
+async function runAIMCP(paths, flags) {
+  await createAIMCPServer({
+    paths,
+    limit: flags.limit ?? 50
+  }).serve(createLineReader(process.stdin), process.stdout);
+}
+function parseAIFlags(args) {
+  const flags = { json: !1, bundle: !1, watch: !1 };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json")
+      flags.json = !0;
+    if (arg === "--bundle")
+      flags.bundle = !0;
+    if (arg === "--watch")
+      flags.watch = !0;
+    if (arg === "--limit")
+      flags.limit = Number(args[i + 1] ?? "0");
+    if (arg === "--interval")
+      flags.intervalMs = Number(args[i + 1] ?? "1000");
+    if (arg === "--port")
+      flags.port = Number(args[i + 1] ?? "4318");
+    if (arg === "--host")
+      flags.host = args[i + 1];
+    if (arg === "--persist")
+      flags.persistPath = args[i + 1];
+    if (arg === "--format") {
+      const format = args[i + 1];
+      if (format === "json" || format === "markdown")
+        flags.format = format;
+    }
+  }
+  return flags;
+}
+function printAIHelp() {
+  console.log(`
+  gorsee ai <subcommand>
+`);
+  console.log("  Subcommands:");
+  console.log("    tail       Read recent structured AI events");
+  console.log("    doctor     Summarize diagnostics and recent incidents");
+  console.log("    replay     Replay correlated AI events in timeline order");
+  console.log("    export     Export a compact AI context packet or bundle");
+  console.log("    pack       Write the latest agent-ready session pack to disk");
+  console.log("    ide-sync   Write IDE-friendly diagnostics/events/context files");
+  console.log("    bridge     Start local HTTP bridge for IDE/agent ingestion");
+  console.log("    mcp        Start stdio MCP server over local AI state");
+  console.log();
+  console.log("  Common flags:");
+  console.log("    --json              Render machine-readable output");
+  console.log("    --format <fmt>      json | markdown");
+  console.log("    --limit <n>         Limit the amount of AI history read");
+  console.log("    --bundle            Include ranked code snippets in export output");
+  console.log("    --watch             Keep IDE projection files in sync");
+  console.log("    --interval <ms>     Watch/poll interval for ide-sync --watch");
+  console.log();
+}

package/dist-pkg/cli/cmd-build.d.ts

@@ -0,0 +1,12 @@
+import { type ClientBuildBackend } from "../build/client-backend.js";
+import { type RuntimeOptions } from "../runtime/project.js";
+import { type AIObservabilityConfig } from "../ai/index.js";
+export interface BuildCommandOptions extends RuntimeOptions {
+    minify?: boolean;
+    sourcemap?: boolean;
+    ai?: AIObservabilityConfig;
+    clientBuildBackend?: ClientBuildBackend;
+}
+export declare function buildProject(options?: BuildCommandOptions): Promise<void>;
+export declare function watchBuildProject(options?: BuildCommandOptions): Promise<void>;
+export declare function runBuild(args: string[], options?: BuildCommandOptions): Promise<void>;