berget 2.2.7 → 2.2.9

package/src/commands/code/__tests__/fake-api-key-service.ts

@@ -1,4 +1,4 @@
-import type { ApiKeyServicePort } from "../ports/auth-services";
+import type { ApiKeyServicePort } from '../ports/auth-services';
 
 export class FakeApiKeyService implements ApiKeyServicePort {
   private readonly _key: string;
@@ -7,7 +7,7 @@ export class FakeApiKeyService implements ApiKeyServicePort {
     this._key = key;
   }
 
-  async create(_options: { name: string; description?: string }): Promise<{ key: string }> {
+  async create(_options: { description?: string; name: string }): Promise<{ key: string }> {
     return { key: this._key };
   }
 }

package/src/commands/code/__tests__/fake-auth-service.ts

@@ -1,14 +1,4 @@
-import type { AuthServicePort } from "../ports/auth-services";
-
-function base64urlEncode(data: string): string {
-  return Buffer.from(data).toString("base64url");
-}
-
-function makeJwt(payload: Record<string, unknown>): string {
-  const header = base64urlEncode(JSON.stringify({ alg: "none", typ: "JWT" }));
-  const body = base64urlEncode(JSON.stringify(payload));
-  return `${header}.${body}.signature`;
-}
+import type { AuthServicePort } from '../ports/auth-services';
 
 export class FakeAuthService implements AuthServicePort {
   loginCallCount = 0;
@@ -17,7 +7,7 @@ export class FakeAuthService implements AuthServicePort {
   constructor(
     private readonly _shouldSucceed: boolean,
     private readonly _hasSeat: boolean = true,
-    private readonly _validToken: boolean = true
+    private readonly _validToken: boolean = true,
   ) {}
 
   async login(): Promise<boolean> {
@@ -25,26 +15,36 @@ export class FakeAuthService implements AuthServicePort {
     return this._shouldSucceed;
   }
 
-  loginInteractive(): ReturnType<AuthServicePort["loginInteractive"]> {
+  loginInteractive(): ReturnType<AuthServicePort['loginInteractive']> {
     this.loginInteractiveCallCount++;
     if (!this._shouldSucceed) {
-      return Promise.resolve({ success: false, error: "Login failed" });
+      return Promise.resolve({ error: 'Login failed', success: false });
     }
 
     const farFuture = Math.floor(Date.now() / 1000) + 3600 * 24 * 365; // 1 year from now in seconds
 
     const accessToken = this._validToken
       ? makeJwt({
-          realm_access: { roles: this._hasSeat ? ["berget_code_seat"] : ["default-roles-berget"] },
           exp: farFuture,
+          realm_access: { roles: this._hasSeat ? ['berget_code_seat'] : ['default-roles-berget'] },
         })
-      : "invalid.token.here";
+      : 'invalid.token.here';
 
     return Promise.resolve({
-      success: true,
       accessToken,
-      refreshToken: "refresh",
       expiresIn: 3600,
+      refreshToken: 'refresh',
+      success: true,
     });
   }
 }
+
+function base64urlEncode(data: string): string {
+  return Buffer.from(data).toString('base64url');
+}
+
+function makeJwt(payload: Record<string, unknown>): string {
+  const header = base64urlEncode(JSON.stringify({ alg: 'none', typ: 'JWT' }));
+  const body = base64urlEncode(JSON.stringify(payload));
+  return `${header}.${body}.signature`;
+}

package/src/commands/code/__tests__/fake-command-runner.ts

@@ -1,19 +1,28 @@
-import type { CommandRunner } from "../ports/command-runner";
+import type { CommandRunner } from '../ports/command-runner';
 
 type Handler = {
-  match: (command: string, args: readonly string[]) => boolean;
-  response: string | Error | ((command: string, args: readonly string[]) => string | Error);
+  match: (command: string, arguments_: readonly string[]) => boolean;
+  response: ((command: string, arguments_: readonly string[]) => Error | string) | Error | string;
 };
 
 export class FakeCommandRunner implements CommandRunner {
+  get calls() {
+    return this._calls;
+  }
+  private _calls: Array<{ args: string[]; command: string; options?: { cwd?: string } }> = [];
+
   private handlers: Handler[] = [];
-  private _calls: Array<{ command: string; args: string[]; options?: { cwd?: string } }> = [];
 
-  handle(match: string | RegExp, response: string | Error): this {
+  checkInstalled(binary: string): Promise<boolean> {
+    this._calls.push({ args: [], command: `check:${binary}` });
+    return Promise.resolve(this.handlers.some((h) => h.match(binary, ['--version'])) || false);
+  }
+
+  handle(match: RegExp | string, response: Error | string): this {
     this.handlers.push({
-      match: (cmd, args) => {
-        const full = `${cmd} ${args.join(" ")}`;
-        if (typeof match === "string") return full.startsWith(match);
+      match: (cmd, arguments_) => {
+        const full = `${cmd} ${arguments_.join(' ')}`;
+        if (typeof match === 'string') return full.startsWith(match);
         return match.test(full);
       },
       response,
@@ -21,24 +30,21 @@ export class FakeCommandRunner implements CommandRunner {
     return this;
   }
 
-  checkInstalled(binary: string): Promise<boolean> {
-    this._calls.push({ command: `check:${binary}`, args: [] });
-    return Promise.resolve(this.handlers.some(h => h.match(binary, ["--version"])) || false);
-  }
-
-  async run(command: string, args: readonly string[], options?: { cwd?: string }): Promise<string> {
-    this._calls.push({ command, args: [...args], options });
-    const handler = this.handlers.find(h => h.match(command, args));
-    if (!handler) throw new Error(`Unexpected command: ${command} ${args.join(" ")}`);
+  async run(
+    command: string,
+    arguments_: readonly string[],
+    options?: { cwd?: string },
+  ): Promise<string> {
+    this._calls.push({ args: [...arguments_], command, options });
+    const handler = this.handlers.find((h) => h.match(command, arguments_));
+    if (!handler) throw new Error(`Unexpected command: ${command} ${arguments_.join(' ')}`);
 
     const result =
-      typeof handler.response === "function" ? handler.response(command, args) : handler.response;
+      typeof handler.response === 'function'
+        ? handler.response(command, arguments_)
+        : handler.response;
 
     if (result instanceof Error) throw result;
     return result;
   }
-
-  get calls() {
-    return this._calls;
-  }
 }

package/src/commands/code/__tests__/fake-file-store.ts

@@ -1,4 +1,4 @@
-import type { FileStore } from "../ports/file-store";
+import type { FileStore } from '../ports/file-store';
 
 export interface FileEntry {
   content: string;
@@ -6,39 +6,39 @@ export interface FileEntry {
 }
 
 export class FakeFileStore implements FileStore {
-  private files: Map<string, string> = new Map();
+  private _chmodCalls: Array<{ mode: number; path: string }> = [];
   private dirs: Set<string> = new Set();
-  private _chmodCalls: Array<{ path: string; mode: number }> = [];
+  private files: Map<string, string> = new Map();
 
-  seed(path: string, content: string): void {
-    this.files.set(path, content);
+  async chmod(path: string, mode: number): Promise<void> {
+    this._chmodCalls.push({ mode, path });
   }
 
   async exists(path: string): Promise<boolean> {
     return this.files.has(path) || this.dirs.has(path);
   }
 
-  async readFile(path: string): Promise<string | null> {
-    return this.files.get(path) ?? null;
+  getChmodCalls(): Array<{ mode: number; path: string }> {
+    return this._chmodCalls;
   }
 
-  async writeFile(path: string, content: string): Promise<void> {
-    this.files.set(path, content);
+  getWrittenFiles(): Map<string, string> {
+    return new Map(this.files);
   }
 
   async mkdir(path: string): Promise<void> {
     this.dirs.add(path);
   }
 
-  async chmod(path: string, mode: number): Promise<void> {
-    this._chmodCalls.push({ path, mode });
+  async readFile(path: string): Promise<null | string> {
+    return this.files.get(path) ?? null;
   }
 
-  getWrittenFiles(): Map<string, string> {
-    return new Map(this.files);
+  seed(path: string, content: string): void {
+    this.files.set(path, content);
   }
 
-  getChmodCalls(): Array<{ path: string; mode: number }> {
-    return this._chmodCalls;
+  async writeFile(path: string, content: string): Promise<void> {
+    this.files.set(path, content);
   }
 }

package/src/commands/code/__tests__/fake-prompter.ts

@@ -1,121 +1,122 @@
-import { CancelledError } from "../errors";
-import type { Prompter, Spinner } from "../ports/prompter";
+import type { Prompter, Spinner } from '../ports/prompter';
 
-export const CANCEL = Symbol("cancel");
+import { CancelledError } from '../errors';
+
+export const CANCEL = Symbol('cancel');
 
 type PromptEntry =
-  | { kind: "select"; match?: RegExp; response: string | symbol }
-  | { kind: "confirm"; match?: RegExp; response: boolean | symbol }
-  | { kind: "text"; match?: RegExp; response: string | symbol }
-  | { kind: "multiselect"; match?: RegExp; response: (string | symbol)[] };
-
-export const select = <T>(value: T | symbol, match?: string | RegExp): PromptEntry => ({
-  kind: "select",
-  match: typeof match === "string" ? new RegExp(match) : match,
-  response: typeof value === "symbol" ? value : String(value),
+  | { kind: 'confirm'; match?: RegExp; response: boolean | symbol }
+  | { kind: 'multiselect'; match?: RegExp; response: (string | symbol)[] }
+  | { kind: 'select'; match?: RegExp; response: string | symbol }
+  | { kind: 'text'; match?: RegExp; response: string | symbol };
+
+export const select = <T>(value: symbol | T, match?: RegExp | string): PromptEntry => ({
+  kind: 'select',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: typeof value === 'symbol' ? value : String(value),
 });
 
-export const text = (value: string | symbol, match?: string | RegExp): PromptEntry => ({
-  kind: "text",
-  match: typeof match === "string" ? new RegExp(match) : match,
+export const text = (value: string | symbol, match?: RegExp | string): PromptEntry => ({
+  kind: 'text',
+  match: typeof match === 'string' ? new RegExp(match) : match,
   response: value,
 });
 
-export const confirm = (value: boolean | symbol, match?: string | RegExp): PromptEntry => ({
-  kind: "confirm",
-  match: typeof match === "string" ? new RegExp(match) : match,
+export const confirm = (value: boolean | symbol, match?: RegExp | string): PromptEntry => ({
+  kind: 'confirm',
+  match: typeof match === 'string' ? new RegExp(match) : match,
   response: value,
 });
 
-export const multiselect = <T>(values: T[] | symbol, match?: string | RegExp): PromptEntry => ({
-  kind: "multiselect",
-  match: typeof match === "string" ? new RegExp(match) : match,
-  response:
-    values === CANCEL ? [CANCEL] : ((values as T[]).map(v => String(v)) as (string | symbol)[]),
+export const multiselect = <T>(values: symbol | T[], match?: RegExp | string): PromptEntry => ({
+  kind: 'multiselect',
+  match: typeof match === 'string' ? new RegExp(match) : match,
+  response: values === CANCEL ? [CANCEL] : ((values as T[]).map(String) as (string | symbol)[]),
 });
 
 export class FakePrompter implements Prompter {
-  private _calls: Array<{ method: string; args: unknown }> = [];
+  get calls() {
+    return this._calls;
+  }
+  private _calls: Array<{ args: unknown; method: string }> = [];
+
   private _cursor = 0;
 
   constructor(private readonly _script: PromptEntry[]) {}
-
+  assertExhausted() {
+    if (this._cursor !== this._script.length) {
+      throw new Error(`Script not exhausted: ${this._script.length - this._cursor} entries left`);
+    }
+  }
+  async confirm(options: { message: string }): Promise<boolean> {
+    this._calls.push({ args: options, method: 'confirm' });
+    const entry = this._script[this._cursor++];
+    if (!entry)
+      throw new Error(`No script entry for confirm #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'confirm')
+      throw new Error(`Expected confirm, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response === CANCEL) throw new CancelledError();
+    return entry.response as boolean;
+  }
   intro(message: string): void {
-    this._calls.push({ method: "intro", args: { message } });
+    this._calls.push({ args: { message }, method: 'intro' });
   }
-  outro(message: string): void {
-    this._calls.push({ method: "outro", args: { message } });
+
+  async multiselect<T>(options: { message: string }): Promise<T[]> {
+    this._calls.push({ args: options, method: 'multiselect' });
+    const entry = this._script[this._cursor++];
+    if (!entry)
+      throw new Error(`No script entry for multiselect #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'multiselect')
+      throw new Error(`Expected multiselect, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
+    if (entry.response.includes(CANCEL)) throw new CancelledError();
+    return entry.response as T[];
   }
+
   note(message: string, title?: string): void {
-    this._calls.push({ method: "note", args: { message, title } });
+    this._calls.push({ args: { message, title }, method: 'note' });
   }
-  spinner(): Spinner {
-    return {
-      start: (msg: string) => {
-        this._calls.push({ method: "spinner.start", args: { message: msg } });
-      },
-      stop: (msg: string) => {
-        this._calls.push({ method: "spinner.stop", args: { message: msg } });
-      },
-    };
+
+  outro(message: string): void {
+    this._calls.push({ args: { message }, method: 'outro' });
   }
 
-  async select<T>(opts: { message: string }): Promise<T> {
-    this._calls.push({ method: "select", args: opts });
+  async select<T>(options: { message: string }): Promise<T> {
+    this._calls.push({ args: options, method: 'select' });
     const entry = this._script[this._cursor++];
-    if (!entry) throw new Error(`No script entry for select #${this._cursor} (${opts.message})`);
-    if (entry.kind !== "select")
-      throw new Error(`Expected select, got ${entry.kind} for ${opts.message}`);
-    if (entry.match && !entry.match.test(opts.message))
-      throw new Error(`Message mismatch: got "${opts.message}"`);
+    if (!entry) throw new Error(`No script entry for select #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'select')
+      throw new Error(`Expected select, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
     if (entry.response === CANCEL) throw new CancelledError();
     return entry.response as T;
   }
 
-  async confirm(opts: { message: string }): Promise<boolean> {
-    this._calls.push({ method: "confirm", args: opts });
-    const entry = this._script[this._cursor++];
-    if (!entry) throw new Error(`No script entry for confirm #${this._cursor} (${opts.message})`);
-    if (entry.kind !== "confirm")
-      throw new Error(`Expected confirm, got ${entry.kind} for ${opts.message}`);
-    if (entry.match && !entry.match.test(opts.message))
-      throw new Error(`Message mismatch: got "${opts.message}"`);
-    if (entry.response === CANCEL) throw new CancelledError();
-    return entry.response as boolean;
+  spinner(): Spinner {
+    return {
+      start: (message: string) => {
+        this._calls.push({ args: { message: message }, method: 'spinner.start' });
+      },
+      stop: (message: string) => {
+        this._calls.push({ args: { message: message }, method: 'spinner.stop' });
+      },
+    };
   }
 
-  async text(opts: { message: string }): Promise<string> {
-    this._calls.push({ method: "text", args: opts });
+  async text(options: { message: string }): Promise<string> {
+    this._calls.push({ args: options, method: 'text' });
     const entry = this._script[this._cursor++];
-    if (!entry) throw new Error(`No script entry for text #${this._cursor} (${opts.message})`);
-    if (entry.kind !== "text")
-      throw new Error(`Expected text, got ${entry.kind} for ${opts.message}`);
-    if (entry.match && !entry.match.test(opts.message))
-      throw new Error(`Message mismatch: got "${opts.message}"`);
+    if (!entry) throw new Error(`No script entry for text #${this._cursor} (${options.message})`);
+    if (entry.kind !== 'text')
+      throw new Error(`Expected text, got ${entry.kind} for ${options.message}`);
+    if (entry.match && !entry.match.test(options.message))
+      throw new Error(`Message mismatch: got "${options.message}"`);
     if (entry.response === CANCEL) throw new CancelledError();
     return entry.response as string;
   }
-
-  async multiselect<T>(opts: { message: string }): Promise<T[]> {
-    this._calls.push({ method: "multiselect", args: opts });
-    const entry = this._script[this._cursor++];
-    if (!entry)
-      throw new Error(`No script entry for multiselect #${this._cursor} (${opts.message})`);
-    if (entry.kind !== "multiselect")
-      throw new Error(`Expected multiselect, got ${entry.kind} for ${opts.message}`);
-    if (entry.match && !entry.match.test(opts.message))
-      throw new Error(`Message mismatch: got "${opts.message}"`);
-    if (entry.response.includes(CANCEL)) throw new CancelledError();
-    return entry.response as T[];
-  }
-
-  get calls() {
-    return this._calls;
-  }
-
-  assertExhausted() {
-    if (this._cursor !== this._script.length) {
-      throw new Error(`Script not exhausted: ${this._script.length - this._cursor} entries left`);
-    }
-  }
 }