@sidekick-coder/zenith-kit 0.0.4 → 0.0.6

package/commands/release.js

@@ -61,7 +61,7 @@ command
         run('npm', ['version', bump])
 
         console.log('\nBuilding...')
-        run('npm', ['run', 'build'])
+        run('npm', ['run', 'build', '--', '--dts'])
 
         console.log('\nPublishing to npm...')
         run('npm', ['publish'])

package/dist/server/index.d.mts

@@ -0,0 +1,154 @@
+import { ChildProcess } from "node:child_process";
+
+//#region src/server/gateways/GitGateway.d.ts
+interface GitRepoInfo {
+  directory: string;
+  head: string | null;
+  shortHash: string;
+  isDetachedHead: boolean;
+  remotes: string[];
+}
+interface GitGatewayOptions {
+  cwd: string;
+  sshKey?: string;
+  sshKeyFile?: string;
+  sshKeyTmpFileName?: string;
+}
+declare class GitGateway {
+  private readonly cwd;
+  private readonly sshKey?;
+  private readonly sshKeyFile?;
+  private readonly sshKeyTmpFileName?;
+  constructor({
+    cwd,
+    sshKey,
+    sshKeyFile,
+    sshKeyTmpFileName
+  }: GitGatewayOptions);
+  private buildEnv;
+  run(args: string): Promise<string>;
+  tryRun(args: string): Promise<string | null>;
+  checkout(ref: string): Promise<void>;
+  fetch(): Promise<void>;
+  pull(): Promise<void>;
+  getInfo(): Promise<GitRepoInfo>;
+}
+//#endregion
+//#region src/server/services/GitBranchRepository.d.ts
+interface GitBranch {
+  name: string;
+  remote: string | null;
+  isCurrent: boolean;
+  isRemote: boolean;
+}
+interface GitBranchFetchOptions {
+  remote: string;
+  branch: string;
+  localName?: string;
+}
+declare class GitBranchRepository {
+  private readonly gateway;
+  constructor(gateway: GitGateway);
+  list(): Promise<GitBranch[]>;
+  fetch(options: GitBranchFetchOptions): Promise<void>;
+}
+//#endregion
+//#region src/server/services/GitCommitRepository.d.ts
+interface GitCommitRef {
+  name: string;
+  shortName: string;
+  type: 'branch' | 'tag' | 'remote' | 'other';
+}
+interface GitCommit {
+  hash: string;
+  shortHash: string;
+  authorName: string;
+  authorEmail: string;
+  date: string;
+  message: string;
+  refs: GitCommitRef[];
+}
+interface GitCommitListOptions {
+  branch?: string;
+  page?: number;
+  perPage?: number;
+}
+interface PaginatedCommits {
+  items: GitCommit[];
+  total: number;
+  page: number;
+  perPage: number;
+  totalPages: number;
+}
+declare class GitCommitRepository {
+  private readonly gateway;
+  constructor(gateway: GitGateway);
+  list(options?: GitCommitListOptions): Promise<PaginatedCommits>;
+}
+//#endregion
+//#region src/server/services/PluginIpcClient.d.ts
+type IpcMessage<T = any> = {
+  id: string;
+  event: string;
+  data: T;
+};
+type IpcListener$1<T = any> = (data: T) => void;
+declare class PluginIpcClient {
+  private listeners;
+  constructor();
+  on<T = any>(event: string, callback: IpcListener$1<T>): void;
+  off<T = any>(event: string, callback: IpcListener$1<T>): void;
+  emit<T = any>(event: string, data?: T): string;
+}
+//#endregion
+//#region src/server/services/PluginIpcHost.d.ts
+type IpcListener<T = any> = (data: T) => void;
+declare class PluginIpcHost {
+  private readonly child;
+  private listeners;
+  constructor(child: ChildProcess);
+  on<T = any>(event: string, callback: IpcListener<T>): void;
+  off<T = any>(event: string, callback: IpcListener<T>): void;
+  emit<T = any>(event: string, data?: T): string;
+}
+//#endregion
+//#region src/server/services/PluginRouter.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface RouteDefinition {
+  method: HttpMethod;
+  path: string;
+}
+interface RouteRequest {
+  requestId: string;
+  method: HttpMethod;
+  path: string;
+  body?: any;
+  headers?: Record<string, string>;
+  query?: Record<string, string>;
+  params?: Record<string, string>;
+}
+interface RouteResponsePayload {
+  requestId: string;
+  status: number;
+  body?: any;
+  headers?: Record<string, string>;
+}
+interface RouteReply {
+  status(code: number): RouteReply;
+  send(body?: any): void;
+}
+type RouteHandler = (req: RouteRequest, reply: RouteReply) => void | Promise<void>;
+declare class PluginRouter {
+  private readonly client;
+  private routes;
+  constructor(client: PluginIpcClient);
+  private dispatch;
+  private register;
+  get(path: string, handler: RouteHandler): void;
+  post(path: string, handler: RouteHandler): void;
+  put(path: string, handler: RouteHandler): void;
+  patch(path: string, handler: RouteHandler): void;
+  delete(path: string, handler: RouteHandler): void;
+}
+//#endregion
+export { GitBranch, GitBranchFetchOptions, GitBranchRepository, GitCommit, GitCommitListOptions, GitCommitRef, GitCommitRepository, GitGateway, GitGatewayOptions, GitRepoInfo, HttpMethod, IpcMessage, PaginatedCommits, PluginIpcClient, PluginIpcHost, PluginRouter, RouteDefinition, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload };

package/dist/server/index.mjs

@@ -1,5 +1,9 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
 //#region src/server/services/GitBranchRepository.ts
 var GitBranchRepository = class {
 	constructor(gateway) {
@@ -280,20 +284,52 @@ function escapeShellArgument(value) {
 }
 var GitGateway = class {
 	cwd;
-	env;
-	constructor({ cwd, sshKey }) {
+	sshKey;
+	sshKeyFile;
+	sshKeyTmpFileName;
+	constructor({ cwd, sshKey, sshKeyFile, sshKeyTmpFileName }) {
 		this.cwd = cwd;
-		this.env = sshKey ? {
-			...process.env,
-			GIT_SSH_COMMAND: `ssh -i ${escapeShellArgument(sshKey)} -o StrictHostKeyChecking=no`
-		} : void 0;
+		this.sshKey = sshKey;
+		this.sshKeyFile = sshKeyFile;
+		this.sshKeyTmpFileName = sshKeyTmpFileName;
+	}
+	async buildEnv() {
+		if (this.sshKeyFile) return {
+			env: {
+				...process.env,
+				GIT_SSH_COMMAND: `ssh -i ${escapeShellArgument(this.sshKeyFile)} -o StrictHostKeyChecking=no`
+			},
+			cleanup: async () => {}
+		};
+		if (this.sshKey) {
+			const tempFile = this.sshKeyTmpFileName ?? join(tmpdir(), `git-ssh-key-${randomUUID()}`);
+			await writeFile(tempFile, this.sshKey, { mode: 384 });
+			return {
+				env: {
+					...process.env,
+					GIT_SSH_COMMAND: `ssh -i ${escapeShellArgument(tempFile)} -o StrictHostKeyChecking=no`
+				},
+				cleanup: async () => {
+					await unlink(tempFile).catch(() => {});
+				}
+			};
+		}
+		return {
+			env: process.env,
+			cleanup: async () => {}
+		};
 	}
 	async run(args) {
-		const { stdout } = await execAsync(`git ${args}`, {
-			cwd: this.cwd,
-			env: this.env
-		});
-		return stdout.trim();
+		const { env, cleanup } = await this.buildEnv();
+		try {
+			const { stdout } = await execAsync(`git ${args}`, {
+				cwd: this.cwd,
+				env
+			});
+			return stdout.trim();
+		} finally {
+			await cleanup();
+		}
 	}
 	async tryRun(args) {
 		try {

package/dist/shared/index.d.mts

@@ -0,0 +1,110 @@
+import * as v from "valibot";
+
+//#region src/shared/services/LoggerService.d.ts
+declare class LoggerService {
+  info(message: string, meta?: any): void;
+  debug(message: string, meta?: any): void;
+  warn(message: string, meta?: any): void;
+  error(message: string, meta?: any): void;
+  child(options: any): LoggerService;
+}
+//#endregion
+//#region src/shared/services/EmmitterService.d.ts
+interface EmmitterServiceOptions {
+  debug?: boolean;
+  logger?: LoggerService;
+}
+//#endregion
+//#region src/shared/utils/typing.d.ts
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PublicData<T> = { [K in keyof T as T[K] extends Function ? never : K]: T[K] };
+//#endregion
+//#region src/shared/utils/compose.d.ts
+type AnyClass = new (...args: any[]) => any;
+type Constructor<T = {}> = new (...args: any[]) => T;
+type Mixin<T> = (base: Constructor) => Constructor<T>;
+/**
+ * Composes multiple mixins into a single class that can be extended.
+ * Allows for multiple inheritance-like behavior by applying mixins sequentially.
+ *
+ * @param mixins - Array of mixin functions to compose
+ * @returns A class constructor that includes all mixin functionality
+ *
+ * @example
+ * ```typescript
+ * class User extends compose(Timestamp, SoftDelete) {
+ *   constructor(public name: string) {
+ *     super()
+ *   }
+ * }
+ * ```
+ */
+declare function compose<M extends Array<(base: Constructor<any>) => Constructor<any>>>(...mixins: M): UnionToIntersection<ReturnType<M[number]>>;
+/**
+ * Alternative compose function that starts with a base class
+ *
+ * @param baseClass - The base class to start with
+ * @param mixins - Array of mixin functions to apply
+ * @returns A class constructor that extends the base class with all mixin functionality
+ *
+ * @example
+ * ```typescript
+ * class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {
+ *   constructor(public name: string) {
+ *     super()
+ *   }
+ * }
+ * ```
+ */
+declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;
+declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;
+//#endregion
+//#region src/shared/services/ValidatorService.d.ts
+type Valibot = typeof v;
+type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;
+type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;
+interface ValidatorCallback<T extends ValibotSchema> {
+  (_v: typeof v): T;
+}
+type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {
+  (_v: typeof v): T;
+};
+type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T, undefined>>;
+type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;
+type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;
+declare class ValidatorService {
+  create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;
+  validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;
+  validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;
+  isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;
+}
+//#endregion
+//#region src/shared/utils/createId.d.ts
+declare function createId(prefix?: string): string;
+//#endregion
+//#region src/shared/utils/flatten.d.ts
+declare function flatten(obj: any, prefix?: string, res?: any): Record<string, any>;
+declare function unflatten(obj: any): Record<string, any>;
+//#endregion
+//#region src/shared/utils/formatBytes.d.ts
+declare function formatBytes(bytes: number, decimals?: number): string;
+//#endregion
+//#region src/shared/utils/generateIndexFile.d.ts
+declare function generateIndexFile(options: any): void;
+//#endregion
+//#region src/shared/utils/tryCatch.d.ts
+interface Tryer {
+  (...args: any[]): any;
+}
+interface TryerAsync {
+  (...args: any[]): Promise<any> | any;
+}
+type TryCatchResult<T extends Tryer> = [null, ReturnType<T>] | [Error, null];
+type TryCatchAsyncResult<T extends TryerAsync> = [null, Awaited<ReturnType<T>>] | [Error, null];
+declare function tryCatch<T extends TryerAsync>(tryer: T): Promise<TryCatchAsyncResult<T>>;
+declare namespace tryCatch {
+  var sync: <T extends Tryer>(tryer: T) => TryCatchResult<T>;
+}
+//#endregion
+export { AnyClass, Constructor, EmmitterServiceOptions, Mixin, PartialBy, PublicData, UnionToIntersection, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, tryCatch, unflatten };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sidekick-coder/zenith-kit",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "license": "MIT",
     "description": "A collection of utilities and tools for building language servers and related applications.",
     "keywords": [],