@proteinjs/reflection-build 1.1.1 → 1.2.1

package/test/examples/source-repository/a/node_modules/@proteinjs/util-node/src/GitUtil.ts

@@ -1,93 +1,155 @@
 import { cmd } from './cmd';
+import type { LogOptions } from './cmd';
+
+type LogPassThrough = { log?: LogOptions };
+
+const DEFAULT_SILENT_LOG: LogOptions = {
+  omitLogs: {
+    stdout: { omit: true },
+    stderr: { omit: true },
+  },
+};
 
 export class GitUtil {
-  static async cloneAppTemplatePackages(directory: string): Promise<void> {
-    const args = ['clone', 'https://github.com/brentbahry/app-template.git', directory];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+  static async cloneAppTemplatePackages(directory: string, opts?: LogPassThrough): Promise<void> {
+    const args = ['clone', 'https://github.com/proteinjs/app-template.git', directory];
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async init(directory: string): Promise<void> {
+  static async init(directory: string, opts?: LogPassThrough): Promise<void> {
     const args = ['init'];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async setRemote(directory: string, remote: string): Promise<void> {
+  static async setRemote(directory: string, remote: string, opts?: LogPassThrough): Promise<void> {
     const args = ['remote', 'set-url', 'origin', remote];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async addRemote(directory: string, remote: string): Promise<void> {
+  static async addRemote(directory: string, remote: string, opts?: LogPassThrough): Promise<void> {
     const args = ['remote', 'add', 'origin', remote];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async commit(directory: string, message: string): Promise<void> {
+  static async commit(directory: string, message: string, opts?: LogPassThrough): Promise<void> {
     const args = ['commit', '-m', message];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async pull(directory: string): Promise<void> {
+  static async pull(directory: string, opts?: LogPassThrough): Promise<void> {
     const args = ['pull'];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async push(directory: string): Promise<void> {
+  static async push(directory: string, opts?: LogPassThrough): Promise<void> {
     const args = ['push'];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async status(directory: string): Promise<void> {
+  static async status(directory: string, opts?: LogPassThrough): Promise<void> {
     const args = ['status'];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
-    }
-    await cmd('git', args, envVars);
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
+  }
+
+  static async addAll(directory: string, opts?: LogPassThrough): Promise<void> {
+    const args = ['add', '-A'];
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
+  }
+
+  static async sync(directory: string, opts?: LogPassThrough): Promise<void> {
+    await GitUtil.pull(directory, opts);
+    await GitUtil.push(directory, opts);
+  }
+
+  /** Return the current branch name. */
+  static async currentBranch(directory: string, opts?: LogPassThrough): Promise<string> {
+    const args = ['rev-parse', '--abbrev-ref', 'HEAD'];
+    const env = directory ? { cwd: directory } : undefined;
+    const { stdout } = await cmd('git', args, env, opts?.log);
+    return String(stdout ?? '').trim();
+  }
+
+  /** Return the current HEAD SHA. */
+  static async headSha(directory: string, opts?: LogPassThrough): Promise<string> {
+    const args = ['rev-parse', 'HEAD'];
+    const env = directory ? { cwd: directory } : undefined;
+    const { stdout } = await cmd('git', args, env, opts?.log);
+    return String(stdout ?? '').trim();
+  }
+
+  /** Create and switch to a new branch. */
+  static async createBranch(directory: string, name: string, opts?: LogPassThrough): Promise<void> {
+    const args = ['checkout', '-b', name];
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
   }
 
-  static async addAll(directory: string): Promise<void> {
-    const args = ['add', '.'];
-    let envVars;
-    if (directory) {
-      envVars = { cwd: directory };
+  /** Checkout an existing branch. */
+  static async checkout(directory: string, name: string, opts?: LogPassThrough): Promise<void> {
+    const args = ['checkout', name];
+    const env = directory ? { cwd: directory } : undefined;
+    await cmd('git', args, env, opts?.log);
+  }
+
+  /** Return a binary-safe patch between two refs (from..to). Defaults to no logging. */
+  static async diffPatch(directory: string, fromRef: string, toRef: string, opts?: LogPassThrough): Promise<string> {
+    const args = ['diff', '--binary', `${fromRef}..${toRef}`];
+    const env = directory ? { cwd: directory } : undefined;
+    const log = opts?.log ?? DEFAULT_SILENT_LOG;
+    const { stdout } = await cmd('git', args, env, log);
+    return String(stdout ?? '');
+  }
+
+  /**
+   * Apply a patch to the working tree (stdin piped). Defaults to no logging.
+   * When `staged` is true, applies to the index only; otherwise as unstaged changes.
+   * When `reverse` is true, applies the patch in reverse.
+   */
+  static async applyPatch(
+    directory: string,
+    patch: string,
+    opts: { staged?: boolean; reverse?: boolean; log?: LogOptions } = {}
+  ): Promise<void> {
+    const args = ['apply', '--whitespace=nowarn'];
+    if (opts.reverse) {
+      args.push('--reverse');
+    }
+    if (opts.staged) {
+      args.push('--cached');
     }
-    await cmd('git', args, envVars);
+    args.push('-'); // read patch from stdin
+    const env = directory ? { cwd: directory } : undefined;
+    const baseLog = opts.log ?? DEFAULT_SILENT_LOG;
+    await cmd('git', args, env, { ...baseLog, stdin: patch });
   }
 
-  static async sync(directory: string): Promise<void> {
-    await GitUtil.pull(directory);
-    await GitUtil.push(directory);
+  static async hasStagedChanges(directory: string, opts?: LogPassThrough): Promise<boolean> {
+    // exit 0 => no staged changes; non-zero => there are staged changes
+    try {
+      await cmd(
+        'git',
+        ['diff', '--cached', '--quiet'],
+        directory ? { cwd: directory } : {},
+        opts?.log ?? DEFAULT_SILENT_LOG
+      );
+      return false;
+    } catch {
+      return true;
+    }
   }
 }
 
+/* ---------- exported function wrappers (unchanged public API) ---------- */
+
 export const cloneAppTemplatePackagesFunctionName = 'cloneAppTemplatePackages';
 export const cloneAppTemplatePackagesFunction = {
   definition: {
@@ -96,10 +158,7 @@ export const cloneAppTemplatePackagesFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory to clone the packages to',
-        },
+        directory: { type: 'string', description: 'The directory to clone the packages to' },
       },
       required: ['directory'],
     },
@@ -115,10 +174,7 @@ export const initFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory to initialize the git repository in',
-        },
+        directory: { type: 'string', description: 'The directory to initialize the git repository in' },
       },
       required: ['directory'],
     },
@@ -134,14 +190,8 @@ export const setRemoteFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
-        remote: {
-          type: 'string',
-          description: 'The remote to set',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
+        remote: { type: 'string', description: 'The remote to set' },
       },
       required: ['directory', 'remote'],
     },
@@ -158,14 +208,8 @@ export const addRemoteFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
-        remote: {
-          type: 'string',
-          description: 'The remote to add',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
+        remote: { type: 'string', description: 'The remote to add' },
       },
       required: ['directory', 'remote'],
     },
@@ -182,14 +226,8 @@ export const commitFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
-        message: {
-          type: 'string',
-          description: 'The commit message',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
+        message: { type: 'string', description: 'The commit message' },
       },
       required: ['directory', 'message'],
     },
@@ -206,10 +244,7 @@ export const pullFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
       },
       required: ['directory'],
     },
@@ -225,10 +260,7 @@ export const pushFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
       },
       required: ['directory'],
     },
@@ -244,10 +276,7 @@ export const statusFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
       },
       required: ['directory'],
     },
@@ -263,10 +292,7 @@ export const addAllFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
       },
       required: ['directory'],
     },
@@ -282,10 +308,7 @@ export const syncFunction = {
     parameters: {
       type: 'object',
       properties: {
-        directory: {
-          type: 'string',
-          description: 'The directory of the git repository',
-        },
+        directory: { type: 'string', description: 'The directory of the git repository' },
       },
       required: ['directory'],
     },
@@ -293,6 +316,115 @@ export const syncFunction = {
   call: async (params: { directory: string }) => await GitUtil.sync(params.directory),
 };
 
+export const currentBranchFunctionName = 'gitCurrentBranch';
+export const currentBranchFunction = {
+  definition: {
+    name: currentBranchFunctionName,
+    description: 'Get the current branch name',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+      },
+      required: ['directory'],
+    },
+  },
+  call: async (params: { directory: string }) => await GitUtil.currentBranch(params.directory),
+};
+
+export const headShaFunctionName = 'gitHeadSha';
+export const headShaFunction = {
+  definition: {
+    name: headShaFunctionName,
+    description: 'Get the SHA of HEAD',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+      },
+      required: ['directory'],
+    },
+  },
+  call: async (params: { directory: string }) => await GitUtil.headSha(params.directory),
+};
+
+export const createBranchFunctionName = 'gitCreateBranch';
+export const createBranchFunction = {
+  definition: {
+    name: createBranchFunctionName,
+    description: 'Create and switch to a new branch',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+        name: { type: 'string', description: 'Branch name' },
+      },
+      required: ['directory', 'name'],
+    },
+  },
+  call: async (params: { directory: string; name: string }) =>
+    await GitUtil.createBranch(params.directory, params.name),
+};
+
+export const checkoutFunctionName = 'gitCheckout';
+export const checkoutFunction = {
+  definition: {
+    name: checkoutFunctionName,
+    description: 'Checkout an existing branch',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+        name: { type: 'string', description: 'Branch name' },
+      },
+      required: ['directory', 'name'],
+    },
+  },
+  call: async (params: { directory: string; name: string }) => await GitUtil.checkout(params.directory, params.name),
+};
+
+export const diffPatchFunctionName = 'gitDiffPatch';
+export const diffPatchFunction = {
+  definition: {
+    name: diffPatchFunctionName,
+    description: 'Return a binary-safe patch between two refs (from..to)',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+        from: { type: 'string', description: 'From ref' },
+        to: { type: 'string', description: 'To ref' },
+      },
+      required: ['directory', 'from', 'to'],
+    },
+  },
+  call: async (params: { directory: string; from: string; to: string }) =>
+    await GitUtil.diffPatch(params.directory, params.from, params.to),
+};
+
+export const applyPatchFunctionName = 'gitApplyPatch';
+export const applyPatchFunction = {
+  definition: {
+    name: applyPatchFunctionName,
+    description: 'Apply a patch to the working tree',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Repository directory' },
+        patch: { type: 'string', description: 'Patch content' },
+        reverse: { type: 'boolean', description: 'Apply in reverse', default: false },
+        staged: { type: 'boolean', description: 'Apply to index/staged only', default: false },
+      },
+      required: ['directory', 'patch'],
+    },
+  },
+  call: async (params: { directory: string; patch: string; reverse?: boolean; staged?: boolean }) =>
+    await GitUtil.applyPatch(params.directory, params.patch, {
+      reverse: !!params.reverse,
+      staged: !!params.staged,
+    }),
+};
+
 export const gitFunctions = [
   cloneAppTemplatePackagesFunction,
   initFunction,
@@ -304,4 +436,10 @@ export const gitFunctions = [
   statusFunction,
   addAllFunction,
   syncFunction,
+  currentBranchFunction,
+  headShaFunction,
+  createBranchFunction,
+  checkoutFunction,
+  diffPatchFunction,
+  applyPatchFunction,
 ];

package/test/examples/source-repository/a/node_modules/@proteinjs/util-node/src/cmd.ts

@@ -1,7 +1,10 @@
 import * as ChildProcess from 'child_process';
 
 export type LogOptions = {
+  /** Prefix each printed line with this string (cosmetic only). */
   logPrefix?: string;
+  /** Optional data to write to the child process stdin, then end() it. */
+  stdin?: string | Buffer;
   omitLogs?: {
     stdout?: {
       omit?: boolean;
@@ -16,9 +19,15 @@ export type LogOptions = {
   };
 };
 
+export type CmdResult = {
+  code: number;
+  stdout: string;
+  stderr: string;
+};
+
 export async function cmd(
   command: string,
-  args?: readonly string[],
+  args: readonly string[] = [],
   options:
     | ChildProcess.SpawnOptionsWithoutStdio
     | ChildProcess.SpawnOptionsWithStdioTuple<
@@ -27,72 +36,88 @@ export async function cmd(
         ChildProcess.StdioPipe | ChildProcess.StdioNull
       > = {},
   logOptions?: LogOptions
-) {
-  const p = ChildProcess.spawn(
-    command,
-    args ? args : [],
-    Object.assign(
-      {
-        cwd: process.cwd(),
-      },
-      options
-    )
-  );
-  return new Promise((resolve, reject) => {
-    p.stdout?.on('data', (x: any) => {
-      if (
-        logOptions?.omitLogs?.stdout?.omit ||
-        (logOptions?.omitLogs?.stdout?.shouldOmit && logOptions.omitLogs.stdout.shouldOmit())
-      ) {
-        return;
-      }
+): Promise<CmdResult> {
+  const proc = ChildProcess.spawn(command, [...args], {
+    cwd: process.cwd(),
+    ...options,
+  });
 
-      const rawLog = x.toString();
-      const filteredLog = logOptions?.omitLogs?.stdout?.filter ? logOptions.omitLogs.stdout.filter(rawLog) : rawLog;
-      if (!filteredLog) {
-        return;
-      }
+  // Use Uint8Array[] to satisfy Buffer.concat's typings across Node versions.
+  const stdoutChunks: Uint8Array[] = [];
+  const stderrChunks: Uint8Array[] = [];
 
-      process.stdout.write(prefixLog(filteredLog, logOptions?.logPrefix));
-    });
-    p.stderr?.on('data', (x) => {
-      if (
-        logOptions?.omitLogs?.stderr?.omit ||
-        (logOptions?.omitLogs?.stderr?.shouldOmit && logOptions.omitLogs.stderr.shouldOmit())
-      ) {
-        return;
-      }
+  const omitStdout = () =>
+    !!(
+      logOptions?.omitLogs?.stdout?.omit ||
+      (logOptions?.omitLogs?.stdout?.shouldOmit && logOptions.omitLogs.stdout.shouldOmit())
+    );
 
-      const rawLog = x.toString();
-      const filteredLog = logOptions?.omitLogs?.stderr?.filter ? logOptions.omitLogs.stderr.filter(rawLog) : rawLog;
-      if (!filteredLog) {
-        return;
-      }
+  const omitStderr = () =>
+    !!(
+      logOptions?.omitLogs?.stderr?.omit ||
+      (logOptions?.omitLogs?.stderr?.shouldOmit && logOptions.omitLogs.stderr.shouldOmit())
+    );
 
-      process.stderr.write(prefixLog(filteredLog, logOptions?.logPrefix));
-    });
-    p.on('error', (error) => {
-      if (
-        logOptions?.omitLogs?.stderr?.omit ||
-        (logOptions?.omitLogs?.stderr?.shouldOmit && logOptions.omitLogs.stderr.shouldOmit())
-      ) {
-        return;
-      }
+  // If caller provided stdin data, write it immediately then end().
+  if (logOptions?.stdin !== undefined && proc.stdin) {
+    proc.stdin.write(logOptions.stdin);
+    proc.stdin.end();
+  }
 
-      const rawLog = error.toString();
-      const filteredLog = logOptions?.omitLogs?.stderr?.filter ? logOptions.omitLogs.stderr.filter(rawLog) : rawLog;
-      if (!filteredLog) {
-        return;
-      }
+  proc.stdout?.on('data', (chunk: Uint8Array) => {
+    stdoutChunks.push(chunk);
+    if (omitStdout()) {
+      return;
+    }
+    const raw = Buffer.from(chunk).toString();
+    const filtered = logOptions?.omitLogs?.stdout?.filter ? logOptions.omitLogs.stdout.filter(raw) : raw;
+    if (filtered) {
+      process.stdout.write(prefixLog(filtered, logOptions?.logPrefix));
+    }
+  });
 
-      process.stderr.write(prefixLog(filteredLog, logOptions?.logPrefix));
+  proc.stderr?.on('data', (chunk: Uint8Array) => {
+    stderrChunks.push(chunk);
+    if (omitStderr()) {
+      return;
+    }
+    const raw = Buffer.from(chunk).toString();
+    const filtered = logOptions?.omitLogs?.stderr?.filter ? logOptions.omitLogs.stderr.filter(raw) : raw;
+    if (filtered) {
+      process.stderr.write(prefixLog(filtered, logOptions?.logPrefix));
+    }
+  });
+
+  return await new Promise<CmdResult>((resolve, reject) => {
+    proc.once('error', (err) => {
+      const stderr = Buffer.concat(stderrChunks as readonly Uint8Array[]).toString();
+      const stdout = Buffer.concat(stdoutChunks as readonly Uint8Array[]).toString();
+      const e = new Error(`spawn error for '${command} ${args.join(' ')}': ${String(err)}`) as Error & {
+        stdout?: string;
+        stderr?: string;
+      };
+      e.stdout = stdout;
+      e.stderr = stderr;
+      reject(e);
     });
-    p.on('exit', (code) => {
-      const logCode = `child process '${command} ${args ? args.join(' ') : ''}' exited with code: ${code}`;
-      if (code === 0) {
-        resolve(code);
+
+    // Use 'close' to ensure stdio is flushed
+    proc.once('close', (code, signal) => {
+      const stdout = Buffer.concat(stdoutChunks as readonly Uint8Array[]).toString();
+      const stderr = Buffer.concat(stderrChunks as readonly Uint8Array[]).toString();
+      const exitCode = typeof code === 'number' ? code : -1;
+
+      if (exitCode === 0) {
+        resolve({ code: exitCode, stdout, stderr });
       } else {
-        reject(logCode);
+        const msg = signal
+          ? `process '${command} ${args.join(' ')}' terminated by signal: ${signal}`
+          : `process '${command} ${args.join(' ')}' exited with code: ${exitCode}`;
+        const err = new Error(msg) as Error & { code: number; stdout: string; stderr: string };
+        err.code = exitCode;
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
       }
     });
   });

package/test/examples/source-repository/a/node_modules/bindings/LICENSE.md

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2012 Nathan Rajlich <nathan@tootallnate.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.