@sidekick-coder/zenith-kit 0.0.1 → 0.0.5

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', '--', '--dts'])
+
+        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.d.mts

@@ -1,5 +1,84 @@
 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;
+}
+declare class GitGateway {
+  private readonly cwd;
+  private readonly env?;
+  constructor({
+    cwd,
+    sshKey
+  }: GitGatewayOptions);
+  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;
@@ -9,12 +88,10 @@ type IpcMessage<T = any> = {
 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
@@ -22,12 +99,10 @@ 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
@@ -69,4 +144,4 @@ declare class PluginRouter {
   delete(path: string, handler: RouteHandler): void;
 }
 //#endregion
-export { HttpMethod, IpcMessage, PluginIpcClient, PluginIpcHost, PluginRouter, RouteDefinition, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload };
+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,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.d.mts

@@ -90,6 +90,9 @@ declare function unflatten(obj: any): Record<string, any>;
 //#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;
@@ -104,4 +107,4 @@ 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 };
+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/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.5",
     "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/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'
-})