@cueloop/extension-api 0.1.0-alpha.16 → 0.1.0-alpha.17

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cueloop/extension-api",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.16"
+    "@cueloop/schema": "0.1.0-alpha.17"
   },
   "publishConfig": {
     "access": "public"

package/src/loader.ts

@@ -1,5 +1,5 @@
 /**
- * Extension discovery and loading (#10): zero-build TypeScript executed
+ * Extension discovery and loading: zero-build TypeScript executed
  * directly. Global user extensions always load; repo-local `.cueloop/
  * extensions/` loads only when the repo is trusted (persisted decisions
  * under the cueloop home).
@@ -51,29 +51,29 @@ export function grantTrust(home: string, repoRoot: string): void {
 function extensionFiles(dir: string): string[] {
   if (!existsSync(dir)) return [];
   return readdirSync(dir)
-    .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
-    .map((f) => join(dir, f))
+    .filter((fileName) => fileName.endsWith(".ts") || fileName.endsWith(".js"))
+    .map((fileName) => join(dir, fileName))
     .sort();
 }
 
-export async function loadExtensions(opts: LoadOptions): Promise<{ loaded: string[]; skipped: string[] }> {
+export async function loadExtensions(options: LoadOptions): Promise<{ loaded: string[]; skipped: string[] }> {
   const loaded: string[] = [];
   const skipped: string[] = [];
   const files: { path: string; source: string }[] = [];
 
-  for (const path of extensionFiles(opts.userDir ?? userExtensionsDir())) {
+  for (const path of extensionFiles(options.userDir ?? userExtensionsDir())) {
     files.push({ path, source: "user" });
   }
-  if (opts.repoRoot) {
-    const repoDir = join(opts.repoRoot, ".cueloop", "extensions");
+  if (options.repoRoot) {
+    const repoDir = join(options.repoRoot, ".cueloop", "extensions");
     const repoFiles = extensionFiles(repoDir);
     if (repoFiles.length) {
-      const home = opts.home ?? join(homedir(), ".cueloop");
+      const home = options.home ?? join(homedir(), ".cueloop");
       const trusted =
-        readTrust(home).trusted.includes(opts.repoRoot) ||
-        (opts.confirmTrust ? await opts.confirmTrust(opts.repoRoot) : false);
+        readTrust(home).trusted.includes(options.repoRoot) ||
+        (options.confirmTrust ? await options.confirmTrust(options.repoRoot) : false);
       if (trusted) {
-        grantTrust(home, opts.repoRoot);
+        grantTrust(home, options.repoRoot);
         for (const path of repoFiles) files.push({ path, source: "repo" });
       } else {
         skipped.push(...repoFiles);
@@ -83,12 +83,12 @@ export async function loadExtensions(opts: LoadOptions): Promise<{ loaded: strin
 
   for (const file of files) {
     try {
-      const mod = (await import(file.path)) as { default?: ExtensionFactory };
-      if (typeof mod.default !== "function") {
+      const extensionModule = (await import(file.path)) as { default?: ExtensionFactory };
+      if (typeof extensionModule.default !== "function") {
         skipped.push(file.path);
         continue;
       }
-      await opts.registry.load(file.path, mod.default);
+      await options.registry.load(file.path, extensionModule.default);
       loaded.push(file.path);
     } catch {
       skipped.push(file.path);

package/src/registry.test.ts

@@ -48,7 +48,7 @@ describe("Registry", () => {
       api.on("session.resolved", () => {
         throw new Error("observer bug");
       });
-      api.on("session.resolved", (s) => seen.push(s.id));
+      api.on("session.resolved", (session) => seen.push(session.id));
     });
     reg.emit("session.resolved", SESSION);
     expect(seen).toEqual(["ses_x"]);

package/src/registry.ts

@@ -1,5 +1,5 @@
 /**
- * The contribution registry (#10): registrations are plain data, attributed
+ * The contribution registry: registrations are plain data, attributed
  * per extension. Reserved app keybindings are rejected at registration so a
  * broken extension cannot shadow core grammar.
  */
@@ -44,19 +44,19 @@ export class Registry {
       registerRenderer(type, renderer) {
         record.renderers.set(type, renderer);
       },
-      registerCommand(cmdName, registration) {
-        record.commands.set(cmdName, registration);
+      registerCommand(commandName, registration) {
+        record.commands.set(commandName, registration);
       },
       registerKeybinding(registration) {
-        const clash = registration.defaultKeys.find((k) => RESERVED_KEYS.has(k));
+        const clash = registration.defaultKeys.find((key) => RESERVED_KEYS.has(key));
         if (clash) {
           record.errors.push(`keybinding "${registration.action}" rejected: "${clash}" is reserved`);
           return;
         }
         record.keybindings.push(registration);
       },
-      registerExporter(expName, exporter) {
-        record.exporters.set(expName, exporter);
+      registerExporter(exporterName, exporter) {
+        record.exporters.set(exporterName, exporter);
       },
       on(event, handler) {
         const list = record.listeners.get(event) ?? [];
@@ -76,24 +76,24 @@ export class Registry {
 
   /** First-registered wins for renderers/commands; built-ins load first. */
   rendererFor(artifactType: string): ArtifactRenderer | undefined {
-    for (const ext of this.extensions) {
-      const r = ext.renderers.get(artifactType);
-      if (r) return r;
+    for (const extension of this.extensions) {
+      const renderer = extension.renderers.get(artifactType);
+      if (renderer) return renderer;
     }
     return undefined;
   }
 
   commandFor(name: string): { extension: string; registration: CommandRegistration } | undefined {
-    for (const ext of this.extensions) {
-      const c = ext.commands.get(name);
-      if (c) return { extension: ext.name, registration: c };
+    for (const extension of this.extensions) {
+      const command = extension.commands.get(name);
+      if (command) return { extension: extension.name, registration: command };
     }
     return undefined;
   }
 
   emit(event: string, session: ReviewSession): void {
-    for (const ext of this.extensions) {
-      for (const handler of ext.listeners.get(event) ?? []) {
+    for (const extension of this.extensions) {
+      for (const handler of extension.listeners.get(event) ?? []) {
         try {
           handler(session);
         } catch {

package/src/types.ts

@@ -1,5 +1,5 @@
 /**
- * The single typed extension contract (#10). This module is import-free
+ * The single typed extension contract. This module is import-free
  * beyond the schema: whatever a declaration file can reach gets published,
  * so the contract stays self-contained.
  *
@@ -32,14 +32,14 @@ export interface CommandContext {
 
 export interface CommandRegistration {
   description: string;
-  handler(ctx: CommandContext, args: string): void | Promise<void>;
+  handler(context: CommandContext, args: string): void | Promise<void>;
 }
 
 export interface KeybindingRegistration {
   /** Action name; binds through the same [keys] config as built-ins. */
   action: string;
   defaultKeys: string[];
-  handler(ctx: CommandContext): void | Promise<void>;
+  handler(context: CommandContext): void | Promise<void>;
 }
 
 /** Exporters ship resolved sessions somewhere (notes vaults, forges). */