@git.zone/cli 1.18.7 → 1.18.8

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/cli',
-    version: '1.18.7',
+    version: '1.18.8',
     description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwrTEFBK0w7Q0FDN00sQ0FBQSJ9

package/dist_ts/mod_commit/index.js

@@ -2,6 +2,7 @@
 import * as plugins from './mod.plugins.js';
 import * as paths from '../paths.js';
 import { logger } from '../gitzone.logging.js';
+import * as helpers from './mod.helpers.js';
 export const run = async (argvArg) => {
     if (argvArg.format) {
         const formatMod = await import('../mod_format/index.js');
@@ -82,10 +83,14 @@ export const run = async (argvArg) => {
     logger.log('info', `Staging files for commit:`);
     await smartshellInstance.exec(`git add -A`);
     await smartshellInstance.exec(`git commit -m "${commitString}"`);
-    await smartshellInstance.exec(`npm version ${commitVersionType}`);
+    // Detect project type and bump version accordingly
+    const projectType = await helpers.detectProjectType();
+    await helpers.bumpProjectVersion(projectType, commitVersionType);
     if (answerBucket.getAnswerFor('pushToOrigin') &&
         !(process.env.CI === 'true')) {
-        await smartshellInstance.exec(`git push origin master --follow-tags`);
+        // Detect current branch instead of hardcoding "master"
+        const currentBranch = await helpers.detectCurrentBranch();
+        await smartshellInstance.exec(`git push origin ${currentBranch} --follow-tags`);
     }
 };
 const createCommitStringFromAnswerBucket = (answerBucket) => {
@@ -94,4 +99,4 @@ const createCommitStringFromAnswerBucket = (answerBucket) => {
     const commitDescription = answerBucket.getAnswerFor('commitDescription');
     return `${commitType}(${commitScope}): ${commitDescription}`;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_commit/mod.helpers.d.ts

@@ -0,0 +1,25 @@
+export type ProjectType = 'npm' | 'deno' | 'both' | 'none';
+export type VersionType = 'patch' | 'minor' | 'major';
+/**
+ * Detects the current git branch
+ * @returns The current branch name, defaults to 'master' if detection fails
+ */
+export declare function detectCurrentBranch(): Promise<string>;
+/**
+ * Detects the project type based on presence of package.json and/or deno.json
+ * @returns The project type
+ */
+export declare function detectProjectType(): Promise<ProjectType>;
+/**
+ * Bumps the version in deno.json
+ * @param versionType Type of version bump
+ * @returns The new version string
+ */
+export declare function bumpDenoVersion(versionType: VersionType): Promise<string>;
+/**
+ * Bumps the project version based on project type
+ * @param projectType The detected project type
+ * @param versionType The type of version bump
+ * @returns The new version string
+ */
+export declare function bumpProjectVersion(projectType: ProjectType, versionType: VersionType): Promise<string>;

package/dist_ts/mod_commit/mod.helpers.js

@@ -0,0 +1,164 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../gitzone.logging.js';
+/**
+ * Detects the current git branch
+ * @returns The current branch name, defaults to 'master' if detection fails
+ */
+export async function detectCurrentBranch() {
+    try {
+        const smartshellInstance = new plugins.smartshell.Smartshell({
+            executor: 'bash',
+            sourceFilePaths: [],
+        });
+        const result = await smartshellInstance.exec('git branch --show-current');
+        const branchName = result.stdout.trim();
+        if (!branchName) {
+            logger.log('warn', 'Could not detect current branch, falling back to "master"');
+            return 'master';
+        }
+        logger.log('info', `Detected current branch: ${branchName}`);
+        return branchName;
+    }
+    catch (error) {
+        logger.log('warn', `Failed to detect branch: ${error.message}, falling back to "master"`);
+        return 'master';
+    }
+}
+/**
+ * Detects the project type based on presence of package.json and/or deno.json
+ * @returns The project type
+ */
+export async function detectProjectType() {
+    const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    const hasPackageJson = await plugins.smartfile.fs.fileExists(packageJsonPath);
+    const hasDenoJson = await plugins.smartfile.fs.fileExists(denoJsonPath);
+    if (hasPackageJson && hasDenoJson) {
+        logger.log('info', 'Detected dual project (npm + deno)');
+        return 'both';
+    }
+    else if (hasPackageJson) {
+        logger.log('info', 'Detected npm project');
+        return 'npm';
+    }
+    else if (hasDenoJson) {
+        logger.log('info', 'Detected deno project');
+        return 'deno';
+    }
+    else {
+        throw new Error('No package.json or deno.json found in current directory');
+    }
+}
+/**
+ * Parses a semantic version string and bumps it according to the version type
+ * @param currentVersion Current version string (e.g., "1.2.3")
+ * @param versionType Type of version bump
+ * @returns New version string
+ */
+function calculateNewVersion(currentVersion, versionType) {
+    const versionMatch = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!versionMatch) {
+        throw new Error(`Invalid version format: ${currentVersion}`);
+    }
+    let [, major, minor, patch] = versionMatch.map(Number);
+    switch (versionType) {
+        case 'major':
+            major += 1;
+            minor = 0;
+            patch = 0;
+            break;
+        case 'minor':
+            minor += 1;
+            patch = 0;
+            break;
+        case 'patch':
+            patch += 1;
+            break;
+    }
+    return `${major}.${minor}.${patch}`;
+}
+/**
+ * Bumps the version in deno.json
+ * @param versionType Type of version bump
+ * @returns The new version string
+ */
+export async function bumpDenoVersion(versionType) {
+    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    try {
+        // Read deno.json
+        const denoConfig = plugins.smartfile.fs.toObjectSync(denoJsonPath);
+        if (!denoConfig.version) {
+            throw new Error('deno.json does not contain a version field');
+        }
+        const currentVersion = denoConfig.version;
+        const newVersion = calculateNewVersion(currentVersion, versionType);
+        logger.log('info', `Bumping deno.json version: ${currentVersion} → ${newVersion}`);
+        // Update version
+        denoConfig.version = newVersion;
+        // Write back to disk
+        await plugins.smartfile.memory.toFs(JSON.stringify(denoConfig, null, 2) + '\n', denoJsonPath);
+        return newVersion;
+    }
+    catch (error) {
+        throw new Error(`Failed to bump deno.json version: ${error.message}`);
+    }
+}
+/**
+ * Bumps the version in package.json using npm version command
+ * @param versionType Type of version bump
+ * @returns The new version string
+ */
+async function bumpNpmVersion(versionType) {
+    const smartshellInstance = new plugins.smartshell.Smartshell({
+        executor: 'bash',
+        sourceFilePaths: [],
+    });
+    logger.log('info', `Bumping package.json version using npm version ${versionType}`);
+    const result = await smartshellInstance.exec(`npm version ${versionType}`);
+    // npm version returns the new version with a 'v' prefix, e.g., "v1.2.3"
+    const newVersion = result.stdout.trim().replace(/^v/, '');
+    return newVersion;
+}
+/**
+ * Syncs the version from package.json to deno.json
+ * @param version The version to sync
+ */
+async function syncVersionToDenoJson(version) {
+    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    try {
+        const denoConfig = plugins.smartfile.fs.toObjectSync(denoJsonPath);
+        logger.log('info', `Syncing version to deno.json: ${version}`);
+        denoConfig.version = version;
+        await plugins.smartfile.memory.toFs(JSON.stringify(denoConfig, null, 2) + '\n', denoJsonPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to sync version to deno.json: ${error.message}`);
+    }
+}
+/**
+ * Bumps the project version based on project type
+ * @param projectType The detected project type
+ * @param versionType The type of version bump
+ * @returns The new version string
+ */
+export async function bumpProjectVersion(projectType, versionType) {
+    switch (projectType) {
+        case 'npm':
+            return await bumpNpmVersion(versionType);
+        case 'deno':
+            return await bumpDenoVersion(versionType);
+        case 'both': {
+            // Bump npm version first (it handles git tags)
+            const newVersion = await bumpNpmVersion(versionType);
+            // Then sync to deno.json
+            await syncVersionToDenoJson(newVersion);
+            return newVersion;
+        }
+        case 'none':
+            throw new Error('Cannot bump version: no package.json or deno.json found');
+        default:
+            throw new Error(`Unknown project type: ${projectType}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@git.zone/cli",
   "private": false,
-  "version": "1.18.7",
+  "version": "1.18.8",
   "description": "A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.",
   "main": "dist_ts/index.ts",
   "typings": "dist_ts/index.d.ts",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '1.18.7',
+  version: '1.18.8',
   description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

package/ts/mod_commit/index.ts

@@ -3,6 +3,7 @@
 import * as plugins from './mod.plugins.js';
 import * as paths from '../paths.js';
 import { logger } from '../gitzone.logging.js';
+import * as helpers from './mod.helpers.js';
 
 export const run = async (argvArg: any) => {
   if (argvArg.format) {
@@ -113,12 +114,18 @@ export const run = async (argvArg: any) => {
   logger.log('info', `Staging files for commit:`);
   await smartshellInstance.exec(`git add -A`);
   await smartshellInstance.exec(`git commit -m "${commitString}"`);
-  await smartshellInstance.exec(`npm version ${commitVersionType}`);
+
+  // Detect project type and bump version accordingly
+  const projectType = await helpers.detectProjectType();
+  await helpers.bumpProjectVersion(projectType, commitVersionType);
+
   if (
     answerBucket.getAnswerFor('pushToOrigin') &&
     !(process.env.CI === 'true')
   ) {
-    await smartshellInstance.exec(`git push origin master --follow-tags`);
+    // Detect current branch instead of hardcoding "master"
+    const currentBranch = await helpers.detectCurrentBranch();
+    await smartshellInstance.exec(`git push origin ${currentBranch} --follow-tags`);
   }
 };
 

package/ts/mod_commit/mod.helpers.ts

@@ -0,0 +1,204 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../gitzone.logging.js';
+
+export type ProjectType = 'npm' | 'deno' | 'both' | 'none';
+export type VersionType = 'patch' | 'minor' | 'major';
+
+/**
+ * Detects the current git branch
+ * @returns The current branch name, defaults to 'master' if detection fails
+ */
+export async function detectCurrentBranch(): Promise<string> {
+  try {
+    const smartshellInstance = new plugins.smartshell.Smartshell({
+      executor: 'bash',
+      sourceFilePaths: [],
+    });
+    const result = await smartshellInstance.exec('git branch --show-current');
+    const branchName = result.stdout.trim();
+
+    if (!branchName) {
+      logger.log('warn', 'Could not detect current branch, falling back to "master"');
+      return 'master';
+    }
+
+    logger.log('info', `Detected current branch: ${branchName}`);
+    return branchName;
+  } catch (error) {
+    logger.log('warn', `Failed to detect branch: ${error.message}, falling back to "master"`);
+    return 'master';
+  }
+}
+
+/**
+ * Detects the project type based on presence of package.json and/or deno.json
+ * @returns The project type
+ */
+export async function detectProjectType(): Promise<ProjectType> {
+  const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+
+  const hasPackageJson = await plugins.smartfile.fs.fileExists(packageJsonPath);
+  const hasDenoJson = await plugins.smartfile.fs.fileExists(denoJsonPath);
+
+  if (hasPackageJson && hasDenoJson) {
+    logger.log('info', 'Detected dual project (npm + deno)');
+    return 'both';
+  } else if (hasPackageJson) {
+    logger.log('info', 'Detected npm project');
+    return 'npm';
+  } else if (hasDenoJson) {
+    logger.log('info', 'Detected deno project');
+    return 'deno';
+  } else {
+    throw new Error('No package.json or deno.json found in current directory');
+  }
+}
+
+/**
+ * Parses a semantic version string and bumps it according to the version type
+ * @param currentVersion Current version string (e.g., "1.2.3")
+ * @param versionType Type of version bump
+ * @returns New version string
+ */
+function calculateNewVersion(currentVersion: string, versionType: VersionType): string {
+  const versionMatch = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)/);
+
+  if (!versionMatch) {
+    throw new Error(`Invalid version format: ${currentVersion}`);
+  }
+
+  let [, major, minor, patch] = versionMatch.map(Number);
+
+  switch (versionType) {
+    case 'major':
+      major += 1;
+      minor = 0;
+      patch = 0;
+      break;
+    case 'minor':
+      minor += 1;
+      patch = 0;
+      break;
+    case 'patch':
+      patch += 1;
+      break;
+  }
+
+  return `${major}.${minor}.${patch}`;
+}
+
+/**
+ * Bumps the version in deno.json
+ * @param versionType Type of version bump
+ * @returns The new version string
+ */
+export async function bumpDenoVersion(versionType: VersionType): Promise<string> {
+  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+
+  try {
+    // Read deno.json
+    const denoConfig = plugins.smartfile.fs.toObjectSync(
+      denoJsonPath
+    ) as { version?: string };
+
+    if (!denoConfig.version) {
+      throw new Error('deno.json does not contain a version field');
+    }
+
+    const currentVersion = denoConfig.version;
+    const newVersion = calculateNewVersion(currentVersion, versionType);
+
+    logger.log('info', `Bumping deno.json version: ${currentVersion} → ${newVersion}`);
+
+    // Update version
+    denoConfig.version = newVersion;
+
+    // Write back to disk
+    await plugins.smartfile.memory.toFs(
+      JSON.stringify(denoConfig, null, 2) + '\n',
+      denoJsonPath
+    );
+
+    return newVersion;
+  } catch (error) {
+    throw new Error(`Failed to bump deno.json version: ${error.message}`);
+  }
+}
+
+/**
+ * Bumps the version in package.json using npm version command
+ * @param versionType Type of version bump
+ * @returns The new version string
+ */
+async function bumpNpmVersion(versionType: VersionType): Promise<string> {
+  const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+    sourceFilePaths: [],
+  });
+
+  logger.log('info', `Bumping package.json version using npm version ${versionType}`);
+  const result = await smartshellInstance.exec(`npm version ${versionType}`);
+
+  // npm version returns the new version with a 'v' prefix, e.g., "v1.2.3"
+  const newVersion = result.stdout.trim().replace(/^v/, '');
+  return newVersion;
+}
+
+/**
+ * Syncs the version from package.json to deno.json
+ * @param version The version to sync
+ */
+async function syncVersionToDenoJson(version: string): Promise<void> {
+  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+
+  try {
+    const denoConfig = plugins.smartfile.fs.toObjectSync(
+      denoJsonPath
+    ) as { version?: string };
+
+    logger.log('info', `Syncing version to deno.json: ${version}`);
+    denoConfig.version = version;
+
+    await plugins.smartfile.memory.toFs(
+      JSON.stringify(denoConfig, null, 2) + '\n',
+      denoJsonPath
+    );
+  } catch (error) {
+    throw new Error(`Failed to sync version to deno.json: ${error.message}`);
+  }
+}
+
+/**
+ * Bumps the project version based on project type
+ * @param projectType The detected project type
+ * @param versionType The type of version bump
+ * @returns The new version string
+ */
+export async function bumpProjectVersion(
+  projectType: ProjectType,
+  versionType: VersionType
+): Promise<string> {
+  switch (projectType) {
+    case 'npm':
+      return await bumpNpmVersion(versionType);
+
+    case 'deno':
+      return await bumpDenoVersion(versionType);
+
+    case 'both': {
+      // Bump npm version first (it handles git tags)
+      const newVersion = await bumpNpmVersion(versionType);
+      // Then sync to deno.json
+      await syncVersionToDenoJson(newVersion);
+      return newVersion;
+    }
+
+    case 'none':
+      throw new Error('Cannot bump version: no package.json or deno.json found');
+
+    default:
+      throw new Error(`Unknown project type: ${projectType}`);
+  }
+}