@beignet/cli 0.0.49 → 0.0.50

package/src/inspect.ts

@@ -4404,6 +4404,7 @@ type WorkflowRegistrationDrift = {
     unregistered: UnregisteredWorkflowRegistry[];
     wiringFile?: string;
     eventBusFile?: string;
+    unsafeLifecycleFiles: string[];
   };
 };
 
@@ -4482,6 +4483,15 @@ async function inspectWorkflowRegistrationDrift(
   }
 
   const infraDir = directoryPath(path.dirname(config.paths.portWiring));
+  for (const file of drift.listeners.unsafeLifecycleFiles) {
+    diagnostics.push({
+      severity: "warning",
+      code: "BEIGNET_LISTENER_LIFECYCLE_UNSAFE",
+      file,
+      message: `${file} calls registerListeners(...) without the complete provider lifecycle, so server startup can resolve before listeners are ready or shutdown can leak subscriptions. Register listeners in start(), return or await registration.ready, and return or await registration.unsubscribe() in stop().`,
+    });
+  }
+
   const listenerTarget = drift.listeners.wiringFile
     ? `${drift.listeners.wiringFile}, which already calls registerListeners(...)`
     : drift.listeners.eventBusFile
@@ -4652,7 +4662,7 @@ async function workflowRegistrationDrift(
       events: [],
       jobs: [],
     },
-    listeners: { unregistered: [] },
+    listeners: { unregistered: [], unsafeLifecycleFiles: [] },
   };
   if (registries.length === 0) return drift;
 
@@ -4714,7 +4724,12 @@ async function workflowRegistrationDrift(
 
   const listenerRegistries = byKind("listeners");
   if (listenerRegistries.length > 0) {
-    const wiring = await listenerWiringReferences(targetDir, files, config);
+    const wiring = await listenerWiringReferences(
+      targetDir,
+      files,
+      config,
+      listenerRegistries,
+    );
     drift.listeners = {
       unregistered: unregisteredWorkflowRegistries(
         listenerRegistries,
@@ -4722,6 +4737,7 @@ async function workflowRegistrationDrift(
       ),
       wiringFile: wiring.wiringFile,
       eventBusFile: wiring.eventBusFile,
+      unsafeLifecycleFiles: wiring.unsafeLifecycleFiles,
     };
   }
 
@@ -5056,12 +5072,15 @@ async function listenerWiringReferences(
   targetDir: string,
   files: string[],
   config: ResolvedBeignetConfig,
+  listenerRegistries: FeatureWorkflowRegistry[],
 ): Promise<{
   identifiers: Set<string>;
   wiringFile?: string;
   eventBusFile?: string;
+  unsafeLifecycleFiles: string[];
 }> {
   const identifiers = new Set<string>();
+  const unsafeLifecycleFiles = new Set<string>();
   let wiringFile: string | undefined;
   let eventBusFile: string | undefined;
   let centralListenerRegistryReferenced = false;
@@ -5073,35 +5092,54 @@ async function listenerWiringReferences(
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const namedImports = parseNamedImportSources(source);
-    let foundCall = false;
-
-    for (const match of source.matchAll(/\bregisterListeners\s*\(/g)) {
-      const openParen = (match.index ?? 0) + match[0].length - 1;
-      const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
-      const argsText =
-        closeParen === -1
-          ? source.slice(openParen)
-          : source.slice(openParen + 1, closeParen);
+    const sourceFile = ts.createSourceFile(
+      file,
+      source,
+      ts.ScriptTarget.Latest,
+      true,
+      file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+    const registerListenersBindings = importedRegisterListenersBindings(
+      source,
+      namedImports,
+    );
+    const calls = registerListenersCalls(sourceFile, registerListenersBindings);
+    let foundRelevantCall = false;
 
-      foundCall = true;
+    for (const call of calls) {
+      const argsText = call.arguments
+        .map((argument) => argument.getText(sourceFile))
+        .join(",");
       const callIdentifiers = identifiersFromArrayExpression(argsText);
+      const referencesCentral = callReferencesCentralListenerRegistry({
+        callIdentifiers,
+        namedImports,
+        importerFile: file,
+        listenerRegistryFile,
+        files,
+      });
+      const referencesFeature = callReferencesFeatureListenerRegistry({
+        callIdentifiers,
+        namedImports,
+        importerFile: file,
+        files,
+        listenerRegistries,
+      });
+      if (!referencesCentral && !referencesFeature) continue;
+
+      foundRelevantCall = true;
       for (const identifier of callIdentifiers) {
         identifiers.add(identifier);
       }
-      if (
-        callReferencesCentralListenerRegistry({
-          callIdentifiers,
-          namedImports,
-          importerFile: file,
-          listenerRegistryFile,
-          files,
-        })
-      ) {
+      if (referencesCentral) {
         centralListenerRegistryReferenced = true;
       }
+      if (!hasSafeListenerRegistrationLifecycle(call, sourceFile)) {
+        unsafeLifecycleFiles.add(file);
+      }
     }
 
-    if (foundCall) {
+    if (foundRelevantCall) {
       wiringFile ??= file;
     } else if (!eventBusFile && /\bcreate\w*EventBus\s*\(/.test(source)) {
       eventBusFile = file;
@@ -5124,7 +5162,368 @@ async function listenerWiringReferences(
     }
   }
 
-  return { identifiers, wiringFile, eventBusFile };
+  return {
+    identifiers,
+    wiringFile,
+    eventBusFile,
+    unsafeLifecycleFiles: [...unsafeLifecycleFiles].sort(),
+  };
+}
+
+type ListenerLifecycleHook =
+  | ts.MethodDeclaration
+  | ts.FunctionExpression
+  | ts.ArrowFunction;
+
+interface ListenerLifecycleTarget {
+  text: string;
+  binding?: ts.Node;
+}
+
+function registerListenersCalls(
+  sourceFile: ts.SourceFile,
+  bindings: ReadonlySet<string>,
+): ts.CallExpression[] {
+  const calls: ts.CallExpression[] = [];
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isCallExpression(node) &&
+      ((ts.isIdentifier(node.expression) &&
+        bindings.has(node.expression.text)) ||
+        (ts.isPropertyAccessExpression(node.expression) &&
+          node.expression.name.text === "registerListeners" &&
+          ts.isIdentifier(node.expression.expression) &&
+          bindings.has(`${node.expression.expression.text}.*`)))
+    ) {
+      calls.push(node);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return calls;
+}
+
+function importedRegisterListenersBindings(
+  source: string,
+  namedImports: Map<string, { importedName: string; sourcePath: string }>,
+): Set<string> {
+  const bindings = new Set<string>();
+  for (const [localName, imported] of namedImports) {
+    if (
+      imported.importedName === "registerListeners" &&
+      imported.sourcePath === "@beignet/core/events"
+    ) {
+      bindings.add(localName);
+    }
+  }
+  const namespaceImport =
+    /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+["']@beignet\/core\/events["']/g;
+  for (const match of source.matchAll(namespaceImport)) {
+    bindings.add(`${match[1]}.*`);
+  }
+  return bindings;
+}
+
+function hasSafeListenerRegistrationLifecycle(
+  call: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+): boolean {
+  const startHook = enclosingListenerLifecycleHook(call, "start");
+  const target = listenerRegistrationTarget(call, sourceFile);
+  if (!startHook || !target) return false;
+  const lifecycleOwner = listenerLifecycleOwner(startHook);
+  if (!lifecycleOwner) return false;
+
+  let observesReadiness = false;
+  let observesCleanup = false;
+  const visit = (node: ts.Node): void => {
+    if (
+      !observesReadiness &&
+      ts.isPropertyAccessExpression(node) &&
+      node.name.text === "ready" &&
+      listenerLifecycleTargetsMatch(
+        listenerLifecycleTarget(node.expression, sourceFile),
+        target,
+      ) &&
+      enclosingListenerLifecycleHook(node, "start") === startHook &&
+      listenerLifecyclePromiseIsObserved(node, startHook)
+    ) {
+      observesReadiness = true;
+    }
+
+    if (
+      !observesCleanup &&
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression) &&
+      node.expression.name.text === "unsubscribe" &&
+      listenerLifecycleTargetsMatch(
+        listenerLifecycleTarget(node.expression.expression, sourceFile),
+        target,
+      )
+    ) {
+      const stopHook = enclosingListenerLifecycleHook(node, "stop");
+      if (
+        stopHook &&
+        listenerLifecycleOwner(stopHook) === lifecycleOwner &&
+        listenerLifecyclePromiseIsObserved(node, stopHook)
+      ) {
+        observesCleanup = true;
+      }
+    }
+
+    if (!observesReadiness || !observesCleanup) {
+      ts.forEachChild(node, visit);
+    }
+  };
+  visit(lifecycleOwner);
+  return observesReadiness && observesCleanup;
+}
+
+function listenerRegistrationTarget(
+  call: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+): ListenerLifecycleTarget | undefined {
+  let expression: ts.Expression = call;
+  while (
+    ts.isParenthesizedExpression(expression.parent) ||
+    ts.isAsExpression(expression.parent) ||
+    ts.isSatisfiesExpression(expression.parent) ||
+    ts.isNonNullExpression(expression.parent)
+  ) {
+    expression = expression.parent;
+  }
+
+  const parent = expression.parent;
+  if (
+    ts.isVariableDeclaration(parent) &&
+    parent.initializer === expression &&
+    ts.isIdentifier(parent.name)
+  ) {
+    return { text: parent.name.text, binding: parent };
+  }
+  if (
+    ts.isBinaryExpression(parent) &&
+    parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+    parent.right === expression
+  ) {
+    return listenerLifecycleTarget(parent.left, sourceFile);
+  }
+  return undefined;
+}
+
+function listenerLifecycleTarget(
+  expression: ts.Expression,
+  sourceFile: ts.SourceFile,
+): ListenerLifecycleTarget | undefined {
+  let current = expression;
+  while (
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+  if (!ts.isIdentifier(current) && !ts.isPropertyAccessExpression(current)) {
+    return undefined;
+  }
+
+  return {
+    text: current.getText(sourceFile),
+    binding: listenerLifecycleRootIdentifier(current)
+      ? resolveListenerLifecycleBinding(
+          listenerLifecycleRootIdentifier(current) as ts.Identifier,
+        )
+      : undefined,
+  };
+}
+
+function listenerLifecycleRootIdentifier(
+  expression: ts.Identifier | ts.PropertyAccessExpression,
+): ts.Identifier | undefined {
+  let current: ts.Expression = expression;
+  while (ts.isPropertyAccessExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isIdentifier(current) ? current : undefined;
+}
+
+function resolveListenerLifecycleBinding(
+  identifier: ts.Identifier,
+): ts.Node | undefined {
+  let current: ts.Node | undefined = identifier;
+  while (current) {
+    if (ts.isBlock(current) || ts.isSourceFile(current)) {
+      for (const statement of current.statements) {
+        if (!ts.isVariableStatement(statement)) continue;
+        for (const declaration of statement.declarationList.declarations) {
+          if (
+            ts.isIdentifier(declaration.name) &&
+            declaration.name.text === identifier.text
+          ) {
+            return declaration;
+          }
+        }
+      }
+    }
+
+    if (ts.isFunctionLike(current)) {
+      for (const parameter of current.parameters) {
+        if (
+          ts.isIdentifier(parameter.name) &&
+          parameter.name.text === identifier.text
+        ) {
+          return parameter;
+        }
+      }
+    }
+
+    if (
+      ts.isCatchClause(current) &&
+      current.variableDeclaration &&
+      ts.isIdentifier(current.variableDeclaration.name) &&
+      current.variableDeclaration.name.text === identifier.text
+    ) {
+      return current.variableDeclaration;
+    }
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function listenerLifecycleTargetsMatch(
+  left: ListenerLifecycleTarget | undefined,
+  right: ListenerLifecycleTarget,
+): boolean {
+  return (
+    left?.text === right.text &&
+    (left.binding !== undefined || right.binding !== undefined
+      ? left.binding === right.binding
+      : true)
+  );
+}
+
+function enclosingListenerLifecycleHook(
+  node: ts.Node,
+  hookName: "start" | "stop",
+): ListenerLifecycleHook | undefined {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (ts.isMethodDeclaration(current)) {
+      return staticPropertyName(current.name) === hookName
+        ? current
+        : undefined;
+    }
+    if (ts.isFunctionExpression(current) || ts.isArrowFunction(current)) {
+      const parent = current.parent;
+      return ts.isPropertyAssignment(parent) &&
+        staticPropertyName(parent.name) === hookName
+        ? current
+        : undefined;
+    }
+    if (ts.isFunctionDeclaration(current)) return undefined;
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function listenerLifecycleOwner(
+  hook: ListenerLifecycleHook,
+): ts.ObjectLiteralExpression | undefined {
+  if (ts.isMethodDeclaration(hook)) {
+    return ts.isObjectLiteralExpression(hook.parent) ? hook.parent : undefined;
+  }
+  const property = hook.parent;
+  return ts.isPropertyAssignment(property) &&
+    ts.isObjectLiteralExpression(property.parent)
+    ? property.parent
+    : undefined;
+}
+
+function listenerLifecyclePromiseIsObserved(
+  node: ts.Node,
+  hook: ListenerLifecycleHook,
+): boolean {
+  let current: ts.Node | undefined = node;
+  while (current && current !== hook) {
+    const parent: ts.Node = current.parent;
+    if (
+      (ts.isAwaitExpression(parent) && parent.expression === current) ||
+      (ts.isReturnStatement(parent) && parent.expression === current)
+    ) {
+      return true;
+    }
+    if (
+      ts.isParenthesizedExpression(parent) ||
+      ts.isAsExpression(parent) ||
+      ts.isSatisfiesExpression(parent) ||
+      ts.isNonNullExpression(parent)
+    ) {
+      current = parent;
+      continue;
+    }
+    if (
+      ts.isPropertyAccessExpression(parent) &&
+      parent.expression === current
+    ) {
+      const method = parent.name.text;
+      const invocation = parent.parent;
+      if (
+        !["then", "catch", "finally"].includes(method) ||
+        !ts.isCallExpression(invocation) ||
+        invocation.expression !== parent ||
+        method === "catch" ||
+        (method === "then" && invocation.arguments.length > 1)
+      ) {
+        return false;
+      }
+      current = invocation;
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+
+function callReferencesFeatureListenerRegistry(args: {
+  callIdentifiers: Set<string>;
+  namedImports: Map<string, { importedName: string; sourcePath: string }>;
+  importerFile: string;
+  files: string[];
+  listenerRegistries: FeatureWorkflowRegistry[];
+}): boolean {
+  for (const identifier of args.callIdentifiers) {
+    for (const registry of args.listenerRegistries) {
+      if (
+        identifier === registry.registryName ||
+        registry.members.includes(identifier)
+      ) {
+        return true;
+      }
+    }
+
+    const imported = args.namedImports.get(identifier);
+    if (!imported) continue;
+    const importedFile = sourceFileFromImport(
+      imported.sourcePath,
+      args.importerFile,
+      args.files,
+    );
+    if (!importedFile) continue;
+
+    for (const registry of args.listenerRegistries) {
+      if (
+        (imported.importedName === registry.registryName &&
+          importedFile === registry.indexFile) ||
+        (registry.members.includes(imported.importedName) &&
+          (importedFile === registry.indexFile ||
+            registry.memberFiles.get(imported.importedName) === importedFile))
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
 
 function callReferencesCentralListenerRegistry(args: {

package/src/lib.ts

@@ -25,6 +25,23 @@ export {
   mapApp,
   projectAppMap,
 } from "./app-map.js";
+export type {
+  AppChangedFile,
+  AppChangeFileScope,
+  AppChangeGap,
+  AppChangeImpact,
+  AppChangeImpactedNode,
+  AppChangeImpactResult,
+  AppChangeReason,
+  AppChangeRelationship,
+  AppMapChangesOptions,
+  BoundedAppChangeGapSection,
+  BoundedAppChangeSection,
+} from "./app-map-changes.js";
+export {
+  formatAppChangeImpact,
+  mapAppChanges,
+} from "./app-map-changes.js";
 export type { CreateOptions } from "./create.js";
 export { createProject } from "./create.js";
 export type {
@@ -71,6 +88,10 @@ export {
   explainTargetKinds,
   formatExplain,
 } from "./explain.js";
+export type {
+  GitChangeComparison,
+  GitChangedFileStatus,
+} from "./git-changes.js";
 export { main } from "./index.js";
 export type {
   ApplyDoctorFixPlanOptions,

package/src/make/shared.ts

@@ -453,36 +453,40 @@ export function wireListenersProviderSource(
 >()({
 \tname: "app-listeners",
 \tsetup({ ports, createServiceContext }) {
-\t\tconst unregister = registerListeners(ports.eventBus, listeners, {
-\t\t\tctx: () =>
-\t\t\t\tcreateServiceContext({
-\t\t\t\t\tactor: createServiceActor("beignet-listener"),
-\t\t\t\t}),
-\t\t\tonError(error, listener) {
-\t\t\t\tports.logger.error("Event listener failed", {
-\t\t\t\t\terror,
-\t\t\t\t\tlistenerName: listener.name,
-\t\t\t\t});
-\t\t\t\tvoid tryReportException({
-\t\t\t\t\treporter: ports.errorReporter,
-\t\t\t\t\terror,
-\t\t\t\t\treportOptions: {
-\t\t\t\t\t\tlevel: "error",
-\t\t\t\t\t\tmechanism: "beignet.listener",
-\t\t\t\t\t\thandled: false,
-\t\t\t\t\t\ttags: {
-\t\t\t\t\t\t\t"beignet.kind": "listener",
-\t\t\t\t\t\t\t"beignet.listener": listener.name,
-\t\t\t\t\t\t},
-\t\t\t\t\t\tcontexts: { listener: { name: listener.name } },
+\t\tlet registration: ReturnType<typeof registerListeners> | undefined;
+
+\t\treturn {
+\t\t\tasync start() {
+\t\t\t\tregistration = registerListeners(ports.eventBus, listeners, {
+\t\t\t\t\tctx: () =>
+\t\t\t\t\t\tcreateServiceContext({
+\t\t\t\t\t\t\tactor: createServiceActor("beignet-listener"),
+\t\t\t\t\t\t}),
+\t\t\t\t\tonError(error, listener) {
+\t\t\t\t\t\tports.logger.error("Event listener failed", {
+\t\t\t\t\t\t\terror,
+\t\t\t\t\t\t\tlistenerName: listener.name,
+\t\t\t\t\t\t});
+\t\t\t\t\t\tvoid tryReportException({
+\t\t\t\t\t\t\treporter: ports.errorReporter,
+\t\t\t\t\t\t\terror,
+\t\t\t\t\t\t\treportOptions: {
+\t\t\t\t\t\t\t\tlevel: "error",
+\t\t\t\t\t\t\t\tmechanism: "beignet.listener",
+\t\t\t\t\t\t\t\thandled: false,
+\t\t\t\t\t\t\t\ttags: {
+\t\t\t\t\t\t\t\t\t"beignet.kind": "listener",
+\t\t\t\t\t\t\t\t\t"beignet.listener": listener.name,
+\t\t\t\t\t\t\t\t},
+\t\t\t\t\t\t\t\tcontexts: { listener: { name: listener.name } },
+\t\t\t\t\t\t\t},
+\t\t\t\t\t\t});
 \t\t\t\t\t},
 \t\t\t\t});
+\t\t\t\tawait registration.ready;
 \t\t\t},
-\t\t});
-
-\t\treturn {
-\t\t\tstop() {
-\t\t\t\tunregister();
+\t\t\tasync stop() {
+\t\t\t\tawait registration?.unsubscribe();
 \t\t\t},
 \t\t};
 \t},

package/src/mcp.ts

@@ -4,6 +4,7 @@ import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { z } from "zod/v4";
 import { mapApp, projectAppMap } from "./app-map.js";
+import { mapAppChanges } from "./app-map-changes.js";
 import { appMapNodeKinds } from "./app-map-schema.js";
 import { checkApp } from "./check.js";
 import {
@@ -579,8 +580,21 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "app_map",
     {
       description:
-        "Return a deterministic graph of this Beignet app: features, contracts, routes, use cases, authorization, workflows, ports, providers, OpenAPI, tests, dependency edges, and validation findings. Project by feature or node kind to keep agent context focused.",
+        "Return a deterministic graph of this Beignet app, or map the current Git change set to bounded, source-backed concepts with changed=true. Changed mode is report-only and exposes unresolved evidence without claiming verification.",
       inputSchema: {
+        changed: z
+          .boolean()
+          .optional()
+          .describe(
+            "Map the current Git change set instead of returning the complete app graph.",
+          ),
+        base: z
+          .string()
+          .min(1)
+          .optional()
+          .describe(
+            "Include committed changes since the merge base of this already-local Git ref. Requires changed=true; Beignet never fetches it.",
+          ),
         feature: z
           .string()
           .optional()
@@ -598,6 +612,22 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     },
     async (input) =>
       safeToolResult(async () => {
+        if (input.base !== undefined && !input.changed) {
+          throw new Error("app_map base requires changed=true.");
+        }
+        if (
+          input.changed &&
+          (input.feature !== undefined ||
+            input.kinds !== undefined ||
+            input.includeDiagnostics !== undefined)
+        ) {
+          throw new Error(
+            "app_map changed=true cannot be combined with feature, kinds, or includeDiagnostics.",
+          );
+        }
+        if (input.changed) {
+          return jsonResult(await mapAppChanges({ cwd, base: input.base }));
+        }
         const result = await mapApp({ cwd, strict: true });
         return jsonResult(
           projectAppMap(result, {
@@ -1166,7 +1196,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
 async function readAppGuidance(cwd: string): Promise<string> {
   const guidancePath = await resolveAppGuidancePath(cwd);
   if (!guidancePath) {
-    return "# Beignet app guidance\n\nNo app-local AGENTS.md was found. Use the app_map and explain tools before editing, prefer Beignet generators, and run check after changes.\n";
+    return "# Beignet app guidance\n\nNo app-local AGENTS.md was found. Use app_map and explain before editing, prefer Beignet generators, use app_map with changed=true to inspect potential consumers after editing in Git, and then run check.\n";
   }
 
   let file: Awaited<ReturnType<typeof open>>;