@sidekick-coder/zenith-kit 0.0.1 → 0.0.4

package/README.md

@@ -0,0 +1,3 @@
+# Zenith-kit 
+
+Services and tools for the Zenith project.

package/artisan.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander'
+import { readdirSync } from 'fs'
+import { resolve, dirname } from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const program = new Command()
+
+program
+    .name('artisan')
+    .description('CLI tool for sc_zenith-kit')
+
+const commandsDir = resolve(__dirname, 'commands')
+
+for (const file of readdirSync(commandsDir)) {
+    if (!file.endsWith('.js')) continue
+
+    const mod = await import(pathToFileURL(resolve(commandsDir, file)).href)
+
+    program.addCommand(mod.default)
+}
+
+program.parse(process.argv)

package/commands/release.js

@@ -0,0 +1,75 @@
+import { Command } from 'commander'
+import { execSync, spawnSync } from 'child_process'
+import readline from 'readline'
+
+function exec(cmd) {
+    return execSync(cmd, { encoding: 'utf-8' }).trim()
+}
+
+function run(cmd, args = []) {
+    const result = spawnSync(cmd, args, { stdio: 'inherit' })
+
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1)
+    }
+}
+
+function ask(question, choices) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+        const list = choices.map((c, i) => `  ${i + 1}) ${c}`).join('\n')
+
+        rl.question(`${question}\n${list}\n> `, (answer) => {
+            rl.close()
+            const index = parseInt(answer, 10) - 1
+
+            if (index >= 0 && index < choices.length) {
+                resolve(choices[index])
+            } else {
+                console.error('Invalid choice.')
+                process.exit(1)
+            }
+        })
+    })
+}
+
+const command = new Command('release')
+
+command
+    .description('Bump version, publish to npm and push to origin')
+    .option('--patch', 'Bump patch version')
+    .option('--minor', 'Bump minor version')
+    .option('--major', 'Bump major version')
+    .action(async (options) => {
+        const staged = exec('git diff --cached --name-only')
+        const unstaged = exec('git diff --name-only')
+
+        if (staged || unstaged) {
+            console.error('Error: there are uncommitted changes. Please commit or stash them before releasing.')
+            process.exit(1)
+        }
+
+        let bump
+
+        if (options.patch) bump = 'patch'
+        else if (options.minor) bump = 'minor'
+        else if (options.major) bump = 'major'
+        else bump = await ask('Select version bump type:', ['patch', 'minor', 'major'])
+
+        console.log(`\nBumping ${bump} version...`)
+        run('npm', ['version', bump])
+
+        console.log('\nBuilding...')
+        run('npm', ['run', 'build'])
+
+        console.log('\nPublishing to npm...')
+        run('npm', ['publish'])
+
+        console.log('\nPushing commit and tag to origin...')
+        run('git', ['push', '--follow-tags'])
+
+        console.log('\nRelease complete.')
+    })
+
+export default command

package/dist/server/index.mjs

@@ -1,3 +1,116 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/server/services/GitBranchRepository.ts
+var GitBranchRepository = class {
+	constructor(gateway) {
+		this.gateway = gateway;
+	}
+	async list() {
+		return (await this.gateway.run(`branch -a --format='%(HEAD)|%(refname:short)|%(refname)|%(upstream:remotename)'`)).split("\n").filter(Boolean).filter((line) => line.includes("|")).map((line) => {
+			const [head, refShort, refFull, remoteName] = line.split("|");
+			const isRemote = refFull.startsWith("refs/remotes/");
+			const name = refShort;
+			return {
+				name,
+				remote: isRemote ? name.split("/")[0] : remoteName || null,
+				isCurrent: head === "*",
+				isRemote
+			};
+		});
+	}
+	async fetch(options) {
+		const { remote, branch, localName } = options;
+		const local = localName ?? branch;
+		await this.gateway.run(`fetch ${remote} ${branch}:${local}`);
+	}
+};
+//#endregion
+//#region src/server/services/GitCommitRepository.ts
+const LOG_FORMAT = [
+	"%H",
+	"%h",
+	"%an",
+	"%ae",
+	"%aI",
+	"%s",
+	"%D"
+].join("%x09");
+function parseDecorations(decorStr) {
+	if (!decorStr.trim()) return [];
+	const refs = [];
+	for (const part of decorStr.split(", ")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		if (trimmed.startsWith("HEAD -> ")) {
+			const shortName = trimmed.slice(8);
+			refs.push({
+				name: "HEAD",
+				shortName: "HEAD",
+				type: "other"
+			});
+			refs.push({
+				name: `refs/heads/${shortName}`,
+				shortName,
+				type: "branch"
+			});
+		} else if (trimmed.startsWith("tag: ")) {
+			const shortName = trimmed.slice(5);
+			refs.push({
+				name: `refs/tags/${shortName}`,
+				shortName,
+				type: "tag"
+			});
+		} else if (trimmed === "HEAD") refs.push({
+			name: "HEAD",
+			shortName: "HEAD",
+			type: "other"
+		});
+		else if (trimmed.includes("/")) refs.push({
+			name: `refs/remotes/${trimmed}`,
+			shortName: trimmed,
+			type: "remote"
+		});
+		else refs.push({
+			name: `refs/heads/${trimmed}`,
+			shortName: trimmed,
+			type: "branch"
+		});
+	}
+	return refs;
+}
+var GitCommitRepository = class {
+	constructor(gateway) {
+		this.gateway = gateway;
+	}
+	async list(options) {
+		const page = options?.page ?? 1;
+		const perPage = options?.perPage ?? 20;
+		const ref = options?.branch ?? "HEAD";
+		const all = (await this.gateway.run(`log ${ref} --format='${LOG_FORMAT}'`)).split("\n").filter(Boolean).map((line) => {
+			const [hash, shortHash, authorName, authorEmail, date, message, decorStr = ""] = line.split("	");
+			return {
+				hash,
+				shortHash,
+				authorName,
+				authorEmail,
+				date,
+				message,
+				refs: parseDecorations(decorStr)
+			};
+		});
+		const total = all.length;
+		const totalPages = Math.ceil(total / perPage);
+		const start = (page - 1) * perPage;
+		return {
+			items: all.slice(start, start + perPage),
+			total,
+			page,
+			perPage,
+			totalPages
+		};
+	}
+};
+//#endregion
 //#region src/shared/utils/createId.ts
 function uuid() {
 	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
@@ -15,13 +128,8 @@ function createId(prefix = "") {
 //#region src/server/services/PluginIpcClient.ts
 var PluginIpcClient = class {
 	listeners = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
 	constructor() {
 		process.on("message", (message) => {
-			if (this.pending.has(message.id)) {
-				this.pending.get(message.id)(message.data);
-				this.pending.delete(message.id);
-			}
 			const handlers = this.listeners.get(message.event);
 			if (!handlers) return;
 			for (const handler of handlers) handler(message.data);
@@ -45,25 +153,14 @@ var PluginIpcClient = class {
 		process.send(message);
 		return id;
 	}
-	emitAsync(event, data) {
-		return new Promise((resolve) => {
-			const id = this.emit(event, data);
-			this.pending.set(id, resolve);
-		});
-	}
 };
 //#endregion
 //#region src/server/services/PluginIpcHost.ts
 var PluginIpcHost = class {
 	listeners = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
 	constructor(child) {
 		this.child = child;
 		this.child.on("message", (message) => {
-			if (this.pending.has(message.id)) {
-				this.pending.get(message.id)(message.data);
-				this.pending.delete(message.id);
-			}
 			const handlers = this.listeners.get(message.event);
 			if (!handlers) return;
 			for (const handler of handlers) handler(message.data);
@@ -87,12 +184,6 @@ var PluginIpcHost = class {
 		this.child.send(message);
 		return id;
 	}
-	emitAsync(event, data) {
-		return new Promise((resolve) => {
-			const id = this.emit(event, data);
-			this.pending.set(id, resolve);
-		});
-	}
 };
 //#endregion
 //#region src/server/services/PluginRouter.ts
@@ -182,4 +273,59 @@ var PluginRouter = class {
 	}
 };
 //#endregion
-export { PluginIpcClient, PluginIpcHost, PluginRouter };
+//#region src/server/gateways/GitGateway.ts
+const execAsync = promisify(exec);
+function escapeShellArgument(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+var GitGateway = class {
+	cwd;
+	env;
+	constructor({ cwd, sshKey }) {
+		this.cwd = cwd;
+		this.env = sshKey ? {
+			...process.env,
+			GIT_SSH_COMMAND: `ssh -i ${escapeShellArgument(sshKey)} -o StrictHostKeyChecking=no`
+		} : void 0;
+	}
+	async run(args) {
+		const { stdout } = await execAsync(`git ${args}`, {
+			cwd: this.cwd,
+			env: this.env
+		});
+		return stdout.trim();
+	}
+	async tryRun(args) {
+		try {
+			return await this.run(args);
+		} catch {
+			return null;
+		}
+	}
+	async checkout(ref) {
+		await this.run(`checkout ${ref}`);
+	}
+	async fetch() {
+		await this.run("fetch --all --prune");
+	}
+	async pull() {
+		await this.fetch();
+		if (await this.tryRun("rev-parse --abbrev-ref --symbolic-full-name @{upstream}")) await this.run("pull --ff-only");
+	}
+	async getInfo() {
+		const head = await this.run("rev-parse --abbrev-ref HEAD");
+		const isDetachedHead = head === "HEAD";
+		const shortHash = await this.run("rev-parse --short HEAD");
+		const remotesOutput = await this.tryRun("remote");
+		const remotes = remotesOutput ? remotesOutput.split("\n").filter(Boolean) : [];
+		return {
+			directory: this.cwd,
+			head: isDetachedHead ? null : head,
+			shortHash,
+			isDetachedHead,
+			remotes
+		};
+	}
+};
+//#endregion
+export { GitBranchRepository, GitCommitRepository, GitGateway, PluginIpcClient, PluginIpcHost, PluginRouter };

package/dist/shared/index.mjs

@@ -1,5 +1,8 @@
 import "lodash-es";
 import * as v from "valibot";
+import fg from "fast-glob";
+import fs from "fs";
+import path from "path";
 //#region src/shared/utils/compose.ts
 /**
 * Composes multiple mixins into a single class that can be extended.
@@ -184,4 +187,20 @@ var ValidatorService = class {
 };
 new ValidatorService();
 //#endregion
-export { ValidatorService, compose, composeWith, createId, flatten, formatBytes, mixin, tryCatch, unflatten };
+//#region src/shared/utils/generateIndexFile.ts
+function generateIndexFile(options) {
+	const folders = options.folders;
+	const filename = options.filename;
+	let content = "";
+	for (const folder of folders) {
+		const files = fg.sync(`${folder}/**/*.ts`, { ignore: ["**/index.ts"] });
+		for (const file of files) {
+			const filePath = path.relative(path.dirname(filename), file);
+			content += `export * from './${filePath}'\n`;
+		}
+	}
+	content = content.trim();
+	fs.writeFileSync(filename, content);
+}
+//#endregion
+export { 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.1",
+    "version": "0.0.4",
     "license": "MIT",
     "description": "A collection of utilities and tools for building language servers and related applications.",
     "keywords": [],
@@ -27,7 +27,9 @@
     },
     "scripts": {
         "generate:indexes": "node indexes.js",
-        "build": "node indexes.js && tsdown"
+        "build": "tsdown",
+        "watch": "tsdown --watch",
+        "release": "node artisan.js release"
     },
     "devDependencies": {
         "@eslint/js": "^9.39.4",
@@ -35,6 +37,7 @@
         "@types/lodash-es": "^4.17.12",
         "@types/node": "^25.6.0",
         "@vue/tsconfig": "^0.9.1",
+        "commander": "^14.0.3",
         "eslint": "^9.39.4",
         "eslint-config-prettier": "^10.1.8",
         "eslint-plugin-vue": "^10.8.0",

package/tsconfig.client.json

@@ -7,7 +7,6 @@
         "strict": true,
         "noUnusedLocals": false,
         "noUnusedParameters": true,
-        "erasableSyntaxOnly": true,
         "noFallthroughCasesInSwitch": true,
         "noUncheckedSideEffectImports": true,
         "strictPropertyInitialization": false,
@@ -21,6 +20,6 @@
     "include": [
         "client/**/**/*.ts",
         "client/**/**/*.vue",
-        "shared/**/**/*.ts",
+        "shared/**/**/*.ts"
     ]
 }

package/tsconfig.server.json

@@ -18,7 +18,6 @@
     "strict": true,
     "noUnusedLocals": false,
     "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true,
     "strictPropertyInitialization": false

package/tsconfig.shared.json

@@ -15,12 +15,11 @@
     "strict": false,
     "noUnusedLocals": false,
     "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true,
     "strictPropertyInitialization": false
   },
   "include": [
-    "src/shared/**/*.ts",
+    "src/shared/**/*.ts"
   ]
 }

package/tsdown.config.ts

@@ -1,14 +1,38 @@
-import { defineConfig } from 'tsdown'
+import { defineConfig, globalLogger } from 'tsdown'
+import { generateIndexFile } from './src/shared/utils/generateIndexFile'
 
 export default defineConfig([
     {
         entry: 'src/shared/index.ts',
         outDir: 'dist/shared',
         tsconfig: 'tsconfig.shared.json',
+        hooks(hooks) {
+            hooks.hook('build:before', async () => {
+                generateIndexFile({
+                    folders: ['src/shared/services', 'src/shared/utils'],
+                    filename: 'src/shared/index.ts'
+                })
+
+                globalLogger.info('Generated index.ts for shared')
+            })
+        }
     },
     {
         entry: 'src/server/index.ts',
         outDir: 'dist/server',
         tsconfig: 'tsconfig.server.json',
+        hooks(hooks) {
+            hooks.hook('build:before', async () => {
+                generateIndexFile({
+                    folders: [
+                        'src/server/services',
+                        'src/server/gateways',
+                    ],
+                    filename: 'src/server/index.ts'
+                })
+
+                globalLogger.info('Generated index.ts for server')
+            })
+        }
     }
 ])

package/dist/server/index.d.mts

@@ -1,72 +0,0 @@
-import { ChildProcess } from "node:child_process";
-
-//#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;
-  private pending;
-  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;
-  emitAsync<TData = any, TReply = any>(event: string, data?: TData): Promise<TReply>;
-}
-//#endregion
-//#region src/server/services/PluginIpcHost.d.ts
-type IpcListener<T = any> = (data: T) => void;
-declare class PluginIpcHost {
-  private readonly child;
-  private listeners;
-  private pending;
-  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;
-  emitAsync<TData = any, TReply = any>(event: string, data?: TData): Promise<TReply>;
-}
-//#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 { HttpMethod, IpcMessage, PluginIpcClient, PluginIpcHost, PluginRouter, RouteDefinition, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload };

package/dist/shared/index.d.mts

@@ -1,107 +0,0 @@
-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/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, mixin, tryCatch, unflatten };

package/indexes.js

@@ -1,37 +0,0 @@
-import fg from 'fast-glob'
-import fs from 'fs'
-import path from 'path'
-
-// generate indexes for folders 
-
-function generate(options) {
-    const folders = options.folders
-    const filename = options.filename
-
-    let content = ''
-
-    for (const folder of folders) {
-        const files = fg.sync(`${folder}/**/*.ts`, { ignore: ['**/index.ts'] })
-
-        for (const file of files) {
-            const filePath = path.relative(path.dirname(filename), file)
-
-            content += `export * from './${filePath}'\n`
-        }
-    }
-
-    content = content.trim()
-
-    fs.writeFileSync(filename, content)
-}
-
-
-generate({
-    folders: ['src/shared/services', 'src/shared/utils'],
-    filename: 'src/shared/index.ts'
-})
-
-generate({
-    folders: ['src/server/services'],
-    filename: 'src/server/index.ts'
-})