@leverege/build-tools 2.113.6 → 2.114.0-DEVOP-578.2

package/src/artifacts/ArtifactPusher.mjs

@@ -1,110 +0,0 @@
-import path from 'node:path'
-import fs from 'node:fs'
-
-import { shellCmd, log, err, debug } from '../Utils.mjs'
-
-import {
-  parseGenericArtifactFileToRemoteRelativePath,
-  parseGenericArtifactSchemaToRemoteRelativePath,
-  listGenericArtifactFiles,
-  shouldUseIgnoreConfiguration,
-  findIgnoreFilePath,
-  copyFilesWithIgnoreConfiguration
-} from './Utils.mjs'
-
-class ArtifactPusher {
-  constructor( path, artifact ) {
-    this.path = path
-    this.artifact = artifact
-  }
-
-  async push() {
-    throw new Error( 'Not implemented' )
-  }
-}
-
-class GenericArtifactPusher extends ArtifactPusher {
-    
-  async push() {
-    log( `Pushing artifact: ${this.artifact.name}` )
-
-    if ( this.artifact.remote_file_path ) {
-      err( 'Remote file path is not supported for pushing artifacts' )
-      return false
-    }
-
-    if ( !this.artifact.local_path && !this.artifact.local_file_path ) {
-      err( 'Local path or local file path is required for pushing artifacts' )
-      return false
-    }
-
-    try {   
-      let command = ''
-
-      command = `gcloud artifacts generic upload \
-      --project=${this.artifact.project} \
-      --location=${this.artifact.location} \
-      --repository=${this.artifact.repository} \
-      --package=${this.artifact.package} \
-      --version=${this.artifact.version}`
-
-      let pathToDelete
-
-      if ( this.artifact.local_path ) {
-        const originalLocalPath = path.join( this.path, this.artifact.local_path )
-
-        let localPath = originalLocalPath
-
-        const useIgnoreConfiguration = await shouldUseIgnoreConfiguration()
-
-        if ( useIgnoreConfiguration ) {
-          const ignoreFilePath = await findIgnoreFilePath( this.path )
-          if ( ignoreFilePath ) {
-            const tmpLocalPath = path.join( '/', 'tmp', `${this.artifact.project}_${this.artifact.location}_${this.artifact.repository}_${this.artifact.package}_${this.artifact.version}` )
-            localPath = tmpLocalPath
-            pathToDelete = tmpLocalPath
-            await copyFilesWithIgnoreConfiguration( originalLocalPath, tmpLocalPath, ignoreFilePath )
-          }
-        }
-
-        command += ` --source-directory=${localPath}`
-        command += ' --skip-existing'
-      } else if ( this.artifact.local_file_path ) {
-
-        const files = await listGenericArtifactFiles( this.artifact )
-
-        const newRemoteFilePath = parseGenericArtifactSchemaToRemoteRelativePath( this.artifact )
-
-        for ( const file of files ) {
-          const existingRemoteFilePath = parseGenericArtifactFileToRemoteRelativePath( file )
-          if ( existingRemoteFilePath === newRemoteFilePath ) {
-            err( `File already exists in the artifact registry:  ${existingRemoteFilePath}` )
-            return false
-          }
-        }
-        const localPath = path.join( this.path, this.artifact.local_file_path )
-        command += ` --source=${localPath}`
-      }
-
-      command += ` --destination-path=${this.artifact.remote_path || '""'}`
-
-      debug( { command }, '<==Upload Command' )
-        
-      await shellCmd( command )
-
-      if ( pathToDelete ) {
-        await fs.promises.rm( pathToDelete, { recursive : true } )
-      }
-
-      log( `Successfully pushed artifact: ${this.artifact.name}` )
-
-      return true
-    } catch ( error ) {
-      debug( { error }, '<==Error Pushing Artifact' )
-      err( `Error pushing artifact: ${this.artifact.name} ${error.message}` )
-      return false
-    }
-  }
-}
-
-export { ArtifactPusher, GenericArtifactPusher }

package/src/artifacts/Structs.mjs

@@ -1,98 +0,0 @@
-import path from 'node:path'
-
-import { assign, coerce, object, string, array, optional, enums, union, refine } from 'superstruct'
-
-const ArtifactTypeEnum = {
-  GENERIC : 'generic',
-}
-
-// Structs with the Partial prefix come from the need to validate the schema with defaults and without defaults merged together.
-
-const PartialArtifactSchema = object( {
-  name : string(),
-  type : optional( enums( Object.values( ArtifactTypeEnum ) ) ),
-  project : optional( string() ),
-  location : optional( string() ),
-  repository : optional( string() ),
-  package : optional( string() ),
-  version : optional( string() )
-} )
-
-const ArtifactSchema = assign( PartialArtifactSchema, object( {
-  name : string(),
-  type : enums( Object.values( ArtifactTypeEnum ) ),
-  project : string(),
-  location : string(),
-  repository : string(),
-  package : string(),
-  version : string()
-} ) )
-
-const normalizedPath = () => coerce( string(), string(), value => path.normalize( value ) )
-
-const PartialGenericArtifactSchema = refine(
-  assign( PartialArtifactSchema, object( {
-    type : optional( enums( [ ArtifactTypeEnum.GENERIC ] ) ),
-    local_file_path : optional( normalizedPath() ),
-    local_path : optional( normalizedPath() ),
-    remote_file_path : optional( normalizedPath() ),
-    remote_path : optional( normalizedPath() )
-  } ) ),
-  'ConflictingPaths',
-  ( value ) => {
-    if ( value.local_file_path && value.local_path ) {
-      return 'Only one of local_file_path or local_path must be provided'
-    }
-    if ( value.remote_file_path && value.remote_path ) {
-      return 'Only one of remote_file_path or remote_path must be provided'
-    }
-    return true
-  }
-)
-
-const GenericArtifactSchema = refine(
-  assign( ArtifactSchema, object( {
-    type : enums( [ ArtifactTypeEnum.GENERIC ] ),
-    local_file_path : optional( normalizedPath() ),
-    local_path : optional( normalizedPath() ),
-    remote_file_path : optional( string() ),
-    remote_path : optional( normalizedPath() )
-  } ) ),
-  'ConflictingPaths',
-  ( value ) => {
-    if ( value.local_file_path && value.local_path ) {
-      return 'Only one of local_file_path or local_path must be provided'
-    }
-    if ( value.remote_file_path && value.remote_path ) {
-      return 'Only one of remote_file_path or remote_path must be provided'
-    }
-    return true
-  }
-)
-
-// Superstruct schema for defaults configuration
-const DefaultsSchema = object( {
-  type : optional( enums( Object.values( ArtifactTypeEnum ) ) ),
-  project : optional( string() ),
-  location : optional( string() ),
-  repository : optional( string() ),
-  package : optional( string() ),
-  version : optional( string() )
-} )
-
-// Superstruct schema for the complete artifacts configuration with defaults
-const ArtifactsSchema = object( {
-  defaults : optional( DefaultsSchema ),
-  artifacts : array( union( [ PartialArtifactSchema, PartialGenericArtifactSchema ] ) )
-} )
-
-const FlattenedArtifactsSchema = array( assign( union( [ ArtifactSchema, GenericArtifactSchema ] ) ) )
-
-export {
-  ArtifactTypeEnum,
-  ArtifactsSchema,
-  FlattenedArtifactsSchema,
-  ArtifactSchema,
-  DefaultsSchema,
-  GenericArtifactSchema,
-}

package/src/artifacts/Utils.mjs

@@ -1,284 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import crypto from 'node:crypto'
-
-import { validate } from 'superstruct'
-
-import { parseYamlFile, err, warning, debug, shellCmd } from '../Utils.mjs'
-
-import { ArtifactTypeEnum, ArtifactsSchema, GenericArtifactSchema } from './Structs.mjs'
-
-const getArtifactsSchema = async ( artifactsFilePath = './artifacts.yaml' ) => {
-  const artifactsConfig = await parseYamlFile( artifactsFilePath )
-  const [ error, result ] = validate( artifactsConfig, ArtifactsSchema )
-  if ( error ) {
-    err( `Invalid artifacts.yml file: ${error.message}` )
-    debug( { err : error }, '<==Invalid artifacts.yml file' )
-    throw new Error( `Invalid artifacts.yml file: ${error.message}` )
-  }
-  return result
-}
-
-const flattenArtifactsSchema = ( artifactsSchema ) => {
-  return artifactsSchema.artifacts.reduce( ( flattenedArtifacts, artifact ) => {
-    const mergedArtifact = {
-      ...artifactsSchema.defaults,
-      ...artifact
-    }
-
-    let schema
-    switch ( mergedArtifact.type ) {
-      case ArtifactTypeEnum.GENERIC:
-        schema = GenericArtifactSchema
-        break
-      default:
-        warning( `Unsupported artifact type "${mergedArtifact.type}"` )
-        break
-    }
-
-    if ( !schema ) {
-      warning( `Invalid artifact type "${mergedArtifact.type}"` )
-      return flattenedArtifacts
-    }
-    
-    const [ error, validatedArtifact ] = validate( mergedArtifact, schema )
-    
-    if ( error ) {
-      warning( `Invalid artifact "${mergedArtifact.name}": ${error.message}` )
-      return flattenedArtifacts
-    }
-    
-    return [ ...flattenedArtifacts, validatedArtifact ]
-  }, [] )
-}
-
-// Example of a file in a generic artifact registry repository:
-// [
-//   {
-//     "createTime": "2025-12-02T17:52:08.694541Z",
-//     "hashes": [
-//       {
-//         "type": "SHA256",
-//         "value": "wrBRqJOUjm-zy6B7YzgKlK0fv9Ad0EEjydBnsmc9Ruw="
-//       },
-//       {
-//         "type": "MD5",
-//         "value": "Ebp3fVphzrITJ461Mg7Kmg=="
-//       }
-//     ],
-//     "name": "projects/leverege-registry/locations/us-central1/repositories/test-generic-registry/files/sweet-poems-1-1764697925426:v1:test1.txt%2Ftest1.txt",
-//     "owner": "projects/leverege-registry/locations/us-central1/repositories/test-generic-registry/packages/sweet-poems-1-1764697925426/versions/v1",
-//     "sizeBytes": "40",
-//     "updateTime": "2025-12-02T17:52:08.694541Z"
-//   }
-// ]
-// Obtained with:gcloud artifacts files list --project=leverege-registry --location=us-central1 --repository=test-generic-registry --package=sweet-poems-1-1764697925426 --version v1 --format="json"
-
-const parseGenericArtifactFileToRemoteRelativePath = ( genericArtifactFile ) => {
-  // "projects/leverege-registry/locations/us-central1/repositories/test-generic-registry/files/sweet-poems-1-1764697925426:v1:test1.txt%2Ftest1.txt"
-  const artifactFileName = genericArtifactFile.name.split( '/' ).pop()
-  // sweet-poems-1-1764697925426:v1:test1.txt%2Ftest1.txt
-  const remoteRelativePath = artifactFileName.split( ':' ).pop().replaceAll( '%2F', '/' )
-  // test1.txt
-  return path.normalize( remoteRelativePath )
-}
-
-const parseGenericArtifactSchemaToRemoteRelativePath = ( genericArtifactSchema ) => {
-  if ( genericArtifactSchema.remote_file_path ) {
-    return path.normalize( genericArtifactSchema.remote_file_path )
-  }
-  if ( genericArtifactSchema.remote_path && genericArtifactSchema.local_file_path ) {
-    return path.join( genericArtifactSchema.remote_path, path.basename( genericArtifactSchema.local_file_path ) )
-  }
-  if ( !genericArtifactSchema.remote_file_path && !genericArtifactSchema.remote_path && genericArtifactSchema.local_file_path ) {
-    return path.basename( genericArtifactSchema.local_file_path )
-  }
-  if ( !genericArtifactSchema.remote_file_path && !genericArtifactSchema.remote_path && genericArtifactSchema.local_file_path ) {
-    return path.basename( genericArtifactSchema.local_file_path )
-  }
-  if ( genericArtifactSchema.remote_path && genericArtifactSchema.local_path ) {
-    return path.normalize( genericArtifactSchema.remote_path )
-  }
-  return path.normalize( '.' )
-}
-
-const parseGenericArtifactSchemaToLocalRelativePath = ( genericArtifactSchema ) => {
-  if ( genericArtifactSchema.local_file_path ) {
-    return path.normalize( genericArtifactSchema.local_file_path )
-  }
-  if ( genericArtifactSchema.local_path && genericArtifactSchema.remote_file_path ) {
-    return path.join( genericArtifactSchema.local_path, path.basename( genericArtifactSchema.remote_file_path ) )
-  }
-  if ( genericArtifactSchema.local_path && !genericArtifactSchema.remote_file_path && !genericArtifactSchema.remote_file_path ) {
-    return path.normalize( genericArtifactSchema.local_path )
-  }
-  if ( !genericArtifactSchema.local_file_path && !genericArtifactSchema.local_path && genericArtifactSchema.remote_file_path ) {
-    return path.basename( genericArtifactSchema.remote_file_path )
-  }
-  return path.normalize( '.' )
-}
-
-const parseGenericArtifactSchemaToArtifactNameBase = ( genericArtifactSchema ) => {
-  const elements = [
-    'projecs',
-    genericArtifactSchema.project,
-    'locations',
-    genericArtifactSchema.location,
-    'repositories',
-    genericArtifactSchema.repository,
-    'files',
-  ]
-  return elements.join( '/' )
-}
-
-const parseGenericArtifactSchemaToArtifactNameFile = ( genericArtifactSchema ) => {
-  // //     "name": "projects/leverege-registry/locations/us-central1/repositories/test-generic-registry/files/sweet-poems-1-1764697925426:v1:test1.txt%2Ftest1.txt",
-
-  const remoteRelativePath = parseGenericArtifactSchemaToRemoteRelativePath( genericArtifactSchema )
-  const encodedRemoteRelativePath = encodeURIComponent( remoteRelativePath )
-
-  const elements = [
-    genericArtifactSchema.package,
-    genericArtifactSchema.version,
-    encodedRemoteRelativePath,
-  ]
-  return elements.join( ':' )
-}
-
-const parseGenericArtifactSchemaToArtifactName = ( genericArtifactSchema ) => {
-  const base = parseGenericArtifactSchemaToArtifactNameBase( genericArtifactSchema )
-  const file = parseGenericArtifactSchemaToArtifactNameFile( genericArtifactSchema )
-
-  const elements = [
-    base,
-    file,
-  ]
-
-  return elements.join( ':' )
-}
-
-const calculateHash = async ( path ) => {
-  try {
-    const hash = crypto.createHash( 'sha256' )
-    hash.update( await fs.promises.readFile( path ) ) // eslint-disable-line security/detect-non-literal-fs-filename
-    return `${hash.digest( 'base64url' )}=`
-  } catch ( error ) {
-    throw new Error( `Failed to calculate hash for artifact ${path}: ${error.message}` )
-  }
-}
-
-const listGenericArtifactFiles = async ( artifact ) => {
-  const command = `gcloud artifacts files list \
-      --project=${artifact.project} \
-      --location=${artifact.location} \
-      --repository=${artifact.repository} \
-      --package=${artifact.package} \
-      --version ${artifact.version} \
-      --format="json"`
-
-  debug( { command }, '<==List Files Command' )
-    
-  const result = await shellCmd( command )
-
-  // Parse the JSON response
-  const files = JSON.parse( result )
-  return files
-}
-
-const getMissingRemoteFiles = async ( genericArtifactFiles, genericArtifactSchemaPath, genericArtifactSchema ) => {
-  
-  const expectedRemoteRelativePath = parseGenericArtifactSchemaToRemoteRelativePath( genericArtifactSchema )
-  const localRelativePath = parseGenericArtifactSchemaToLocalRelativePath( genericArtifactSchema )
-  const expectedLocalRelativePath = path.join( genericArtifactSchemaPath, localRelativePath )
-
-  const actualFiles = new Set()
-  const expectedFiles = new Set()
-  
-  for ( const file of genericArtifactFiles ) {
-    const actualRemoteFilePath = parseGenericArtifactFileToRemoteRelativePath( file )
-    const actualRemoteFileHash = file.hashes.find( hash => hash.type === 'SHA256' ).value
-    actualFiles.add( { remoteFilePath : actualRemoteFilePath, remoteFileHash : actualRemoteFileHash } )
-  }
-
-  /* eslint-disable security/detect-non-literal-fs-filename */
-  if ( ( await fs.promises.stat( expectedLocalRelativePath ) ).isDirectory() ) {
-    const localFiles = await fs.promises.readdir( expectedLocalRelativePath, { withFileTypes : true, recursive : true } )
-    for ( const localFile of localFiles ) {
-      if ( localFile.isDirectory() ) {
-        continue
-      }
-
-      const expectedRemoteFilePath = path.join( expectedRemoteRelativePath, localFile.path.replace( expectedLocalRelativePath, '' ), localFile.name )
-      const expectedLocalFilePath = path.join( localFile.path, localFile.name )
-      // eslint-disable-next-line no-await-in-loop
-      expectedFiles.add( { remoteFilePath : expectedRemoteFilePath, remoteFileHash : await calculateHash( expectedLocalFilePath ) } )
-    }
-  } else {
-    const expectedRemoteFilePath = expectedRemoteRelativePath
-    const expectedLocalFilePath = expectedLocalRelativePath
-    expectedFiles.add( { remoteFilePath : expectedRemoteFilePath, remoteFileHash : await calculateHash( expectedLocalFilePath ) } )
-  }
-  /* eslint-enable security/detect-non-literal-fs-filename */
-
-  const actualArray = Array.from( actualFiles )
-  const expectedArray = Array.from( expectedFiles )
-
-  return expectedArray.filter( expected => !actualArray.some( actual => actual.remoteFilePath === expected.remoteFilePath && actual.remoteFileHash === expected.remoteFileHash ) )
-}
-
-const shouldUseIgnoreConfiguration = async () => {
-  let result
-  try {
-    result = await shellCmd( 'gcloud config get-value gcloudignore/enabled' )
-    if ( result.trim() === '' || result.includes( 'has no property' ) ) {
-      return false
-    }
-    return result.trim() === 'true'
-  } catch ( error ) {
-    if ( error.message && error.message.includes( 'Section [gcloudignore] has no property [enabled]' ) ) {
-      return false
-    }
-    // Re-throw other errors
-    throw error
-  }
-}
-
-const findIgnoreFilePath = async ( relativePath ) => {
-  if ( relativePath ) {
-    const ignoreFilePath = path.join( relativePath, '.gcloudignore' )
-    if ( fs.existsSync( ignoreFilePath ) ) { // eslint-disable-line security/detect-non-literal-fs-filename
-      return ignoreFilePath
-    }
-  }
-
-  const ignoreFilePath = path.join( process.cwd(), '.gcloudignore' )
-  if ( fs.existsSync( ignoreFilePath ) ) {
-    return ignoreFilePath
-  }
-
-  return null
-}
-
-const copyFilesWithIgnoreConfiguration = async ( sourcePath, destinationPath, ignoreFilePath ) => {
-  // Ensure sourcePath ends with / so rsync copies contents (not the folder itself) and exclude patterns work correctly
-  const normalizedSourcePath = sourcePath.endsWith( '/' ) ? sourcePath : `${sourcePath}/`
-  const command = `rsync -av --delete --exclude-from='${ignoreFilePath}' ${normalizedSourcePath} ${destinationPath}`
-  await shellCmd( command )
-}
-
-export {
-  calculateHash,
-  getArtifactsSchema,
-  flattenArtifactsSchema,
-  parseGenericArtifactFileToRemoteRelativePath,
-  parseGenericArtifactSchemaToRemoteRelativePath,
-  parseGenericArtifactSchemaToLocalRelativePath,
-  parseGenericArtifactSchemaToArtifactNameBase,
-  parseGenericArtifactSchemaToArtifactNameFile,
-  parseGenericArtifactSchemaToArtifactName,
-  getMissingRemoteFiles,
-  listGenericArtifactFiles,
-  shouldUseIgnoreConfiguration,
-  findIgnoreFilePath,
-  copyFilesWithIgnoreConfiguration
-}

package/src/artifacts/pull-artifact.mjs

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path'
-
-import { program } from 'commander'
-
-import { warning, log } from '../Utils.mjs'
-
-import { getArtifactsSchema, flattenArtifactsSchema } from './Utils.mjs'
-import { ArtifactTypeEnum } from './Structs.mjs'
-import { GenericArtifactPuller } from './ArtifactPuller.mjs'
-
-program
-  .name( 'pull-artifact' )
-  .description( 'Pull artifacts from GCP Artifact Registry' )
-  .option( '-f, --file-path <file-path>', 'Path to artifacts.yaml file', './artifacts.yaml' )
-  .option( '-a, --artifact-path <artifact-path>', 'GCP artifact path' )
-  .parse()
-
-const options = program.opts()
-
-async function main() {
-  const artifactsSchema = await getArtifactsSchema( options.filePath )
-  const flattenedArtifactsSchema = flattenArtifactsSchema( artifactsSchema )
-
-  let filteredArtifactsSchema = flattenedArtifactsSchema
-
-  if ( options.artifactPath ) {
-    const artifactPathElements = options.artifactPath.split( '/' )
-
-    if ( artifactPathElements.length !== 5 ) {
-      warning( 'Invalid artifact path, it must be in the format <project>/<location>/<repository>/<package>/<version>' )
-      return false
-    }
-
-    const [ project, location, repository, packageName, version ] = artifactPathElements
-
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.project === project &&
-      artifact.location === location &&
-      artifact.repository === repository &&
-      artifact.package === packageName &&
-      artifact.version === version )
-  }
-
-  let counter = 0
-
-  const pullResults = await Promise.all(
-    filteredArtifactsSchema.map( async ( artifactSchema ) => {
-      let puller
-      switch ( artifactSchema.type ) {
-        case ArtifactTypeEnum.GENERIC:
-          puller = new GenericArtifactPuller( path.dirname( options.filePath ), artifactSchema )
-          break
-        default:
-          warning( `Unsupported artifact type "${artifactSchema.type}"` )
-          return false
-      }
-
-      if ( !puller ) {
-        warning( `Unsupported artifact type "${artifactSchema.type}"` )
-        return false
-      }
-
-      try {
-        return await puller.pull()
-      } catch ( error ) {
-        warning( `Error pulling artifact "${artifactSchema.name}": ${error.message}` )
-        return false
-      }
-    } )
-  )
-
-  counter = pullResults.filter( Boolean ).length
-
-  log( `Successfully pulled ${counter}/${filteredArtifactsSchema.length} artifacts` )
-
-  return counter === filteredArtifactsSchema.length
-}
-
-main()

package/src/artifacts/push-artifact.mjs

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path'
-
-import { program } from 'commander'
-
-import { warning, log } from '../Utils.mjs'
-
-import { getArtifactsSchema, flattenArtifactsSchema } from './Utils.mjs'
-import { ArtifactTypeEnum } from './Structs.mjs'
-import { GenericArtifactPusher } from './ArtifactPusher.mjs'
-
-program
-  .name( 'push-artifact' )
-  .description( 'Push artifacts to GCP Artifact Registry' )
-  .option( '-f, --file-path <file-path>', 'Path to artifacts.yaml file', './artifacts.yaml' )
-  .option( '-a, --artifact-path <artifact-path>', 'GCP artifact path' )
-  .parse()
-
-const options = program.opts()
-
-async function main() {
-  const artifactsSchema = await getArtifactsSchema( options.filePath )
-  const flattenedArtifactsSchema = flattenArtifactsSchema( artifactsSchema )
-
-  let filteredArtifactsSchema = flattenedArtifactsSchema
-
-  if ( options.artifactPath ) {
-    const artifactPathElements = options.artifactPath.split( '/' )
-    if ( artifactPathElements.length !== 5 ) {
-      warning( 'Invalid artifact path, it must be in the format <project>/<location>/<repository>/<package>/<version>' )
-      return false
-    }
-
-    const [ project, location, repository, packageName, version ] = artifactPathElements
-
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.project === project &&
-      artifact.location === location &&
-      artifact.repository === repository &&
-      artifact.package === packageName &&
-      artifact.version === version )
-  }
-
-  let counter = 0
-
-  const pushResults = await Promise.all(
-    filteredArtifactsSchema.map( async ( artifactSchema ) => {
-      let pusher
-      switch ( artifactSchema.type ) {
-        case ArtifactTypeEnum.GENERIC:
-          pusher = new GenericArtifactPusher( path.dirname( options.filePath ), artifactSchema )
-          break
-        default:
-          warning( `Unsupported artifact type "${artifactSchema.type}"` )
-          return false
-      }
-
-      if ( !pusher ) {
-        warning( `Unsupported artifact type "${artifactSchema.type}"` )
-        return false
-      }
-
-      try {
-        return await pusher.push()
-      } catch ( error ) {
-        warning( `Error pushing artifact "${artifactSchema.name}": ${error.message}` )
-        return false
-      }
-    } )
-  )
-
-  counter = pushResults.filter( Boolean ).length
-
-  log( `Successfully pushed ${counter}/${filteredArtifactsSchema.length} artifacts` )
-  
-  return counter === filteredArtifactsSchema.length
-}
-
-main()

package/src/change-up.sh

@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-version="${1:-X.Y.Z}"
-date_str=$(date +%F)  # e.g., 2025-12-11
-
-cat <<EOF
-## [$version] - $date_str
-
-### Added
--
-
-### Changed
--
-
-### Deprecated
--
-
-### Removed
--
-
-### Fixed
--
-
-### Migration Notes
--
-EOF