imdone-cli 0.1.5 → 0.1.7

package/src/adapters/__tests__/create-jwt.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Generate a 2048-bit RSA private key (unencrypted)
-openssl genpkey -algorithm RSA -out ./jwt-private.pem -pkeyopt rsa_keygen_bits:2048
-
-# Extract the public key from the private key
-openssl rsa -pubout -in ./jwt-private.pem -out jwt-public.pem
-
-echo "✅ RSA 2048-bit key pair generated in ./keys/"

package/src/adapters/__tests__/jwt-private.pem

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC/zPuZfQQyke5+
-KUs2AeKt4BMbO0TZgSt+1pLYzXXhtKj5qVn0GUY1QS03F3/dksUS+oND9jmyxBoK
-0IdLUKa1pX66rM8nTb3fMYk+wVAn+oBK1hKSv/pCWkrw/oN19aAzl9yf5+BWBym1
-JkoXYlU3607PPWzMZ26lZ/xGUpMsKHQmdX2Enk7ZfoHdT7xhnUkP+dQ5Qdf2rUyf
-Y58Bb7yJtWlo00O0bs4+oBH4d5N+Ft/Qx3LxHKlDL374G+28fImT2tfAiYYs9Ash
-diiecv1RTjNxtVFoo34Vu8x1eQMsoWLjtQKdMB5UxmmobwiYfULwyweCXKJuvo9L
-MQK2zQRlAgMBAAECggEADxL+dDf/4DSZdKdsrpQz21wIzGNaXCjbgQa+uFTfjqtq
-+2I8vGNPIgjbE6Egbsrl+8GeFvWPX9YrQM3WUExIqe6VmPjTeCCTS2sigQDi+p1k
-v1z3TTrS4aukh6/NJ7R0EJH/KD8qYcCC3eaiPJfBIFm5Ui7e8eqwJsZXLLS5Nede
-CjkdCTbHA3hSJIplEFSiTDrV7TTg+s9PwZV0GboOmUS9zmFBWRr1VTsPit5YbRty
-VmvI89XDQROMimMmrL9v9dK0TeqzFABDi+Sad5lR5udxov9BfZWUEaBcwmpxh7kt
-TaOPTXAw/wv9X05rBr0dmkoUEhyoeIk6aELyqSD6sQKBgQDzxsItdxYAoPufort8
-D0qEdYlahISVnH23Yv7Q/+Hr5uZs7WG6MPYiPe5nSgYQcnA/IgXB2yebbM1vm6dD
-nHIXYVmw/pB/1rIlqbxlvOf7eUiQ39FVp4h2LWSeY0aI0dg+XL6cpULf5n0+bJCD
-/i01d6NcEPOxYPfbJsEFgckM0QKBgQDJawmE/lhxsgCcR+WxxDeGciZQIOydjr4/
-caN062qijxXB6lZAi9fg0EcReuVmsXLw25TOHi9ABON6FftdbagTk9lgrcTWo21F
-XxD1AeJoQUwlort3AnJ8SS/1b1C2KX8S3hI4vX2RXuqUGgubBdW4Y5aC0KOZAqhz
-Yb0xGqRTVQKBgDxLwyeftu984gAALkNnPNU6hTjAYlLnHClJ8SEcyXKh8AitRmjZ
-R2f8zYT6yDk1NRJIhggG/urwpHeglmSgw4+I4rhmnrMgFXw/WXwIl5CZ1RsQYSTA
-hX5FiAetInsg/E2gfv0b20iqJ/xSugQL0H7TErLo9n2/ME8ibMfB7EqhAoGAbsUI
-5TUj2tMz9r6rmcn5Z10bqPGSb0vzYNzUMhbN/DyIkK6ZZMIDpUWl7/0QcBuixMdd
-3MVI4wJNP/Ua2lTWHH4xDDREjm4uR/pyTuwMYZ2XjRMj2d1krOlrEKV5U9UaZ3vt
-tXqwtePnSi/Qth7NXKyYN7UaY6nMjjfwXjLysEkCgYB4b+1gVzuPWBZsJbo/yX2Q
-HWjdwL9EgbaFHvqI6DVoMBMux+KB5KKVTn+yRS2NAR7fxdYsVeEz+z8ftfVbXRpt
-7dpPJxBe+MpoOojGkpg8UC1/SIwG2Qtg4QDgdCK2QS8JbeRpziK0GyLIfiSG5i4R
-CX69OWZrIxmbTy9Vun0nCg==
------END PRIVATE KEY-----

package/src/adapters/__tests__/jwt-public.pem

@@ -1,9 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv8z7mX0EMpHufilLNgHi
-reATGztE2YErftaS2M114bSo+alZ9BlGNUEtNxd/3ZLFEvqDQ/Y5ssQaCtCHS1Cm
-taV+uqzPJ0293zGJPsFQJ/qAStYSkr/6QlpK8P6DdfWgM5fcn+fgVgcptSZKF2JV
-N+tOzz1szGdupWf8RlKTLCh0JnV9hJ5O2X6B3U+8YZ1JD/nUOUHX9q1Mn2OfAW+8
-ibVpaNNDtG7OPqAR+HeTfhbf0Mdy8RypQy9++BvtvHyJk9rXwImGLPQLIXYonnL9
-UU4zcbVRaKN+FbvMdXkDLKFi47UCnTAeVMZpqG8ImH1C8MsHglyibr6PSzECts0E
-ZQIDAQAB
------END PUBLIC KEY-----

package/src/adapters/__tests__/license.spec.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateLicense, verifyLicense } from "../license";
-import { fileURLToPath } from 'url';
-import path from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-describe("License Generation and Verification", () => {
-  const privateKeyPath = path.join(__dirname, 'jwt-private.pem');
-  const publicKeyPath = path.join(__dirname, 'jwt-public.pem');
-  const payload = {
-    name: "Test User",
-    email: "test@test.com",
-    org: "Test Organization",
-    plan: "premium",
-    expiresIn: "30d",
-  };
-  
-  it("should generate a valid license", async () => {
-    const license = await generateLicense(payload, privateKeyPath);
-    expect(license).toBeDefined();
-    expect(typeof license).toBe("string");
-    const decoded = await verifyLicense(license, publicKeyPath);
-    expect(decoded.valid).toBe(true);
-  });
-})

package/src/adapters/env.js

@@ -1,21 +0,0 @@
-import { envExists as envExistsAdapter, appendToEnv, initEnv } from "../../../src/adapters/env";
-import { logger } from "imdone-core/lib/adapters/logger.js";
-export async function envExists(projectPath) {
-  return envExistsAdapter(projectPath)
-}
-
-export async function storeJiraCredentials(projectPath, jiraUsername, jiraApiToken) {
-  await appendToEnv(projectPath, 'JIRA_USERNAME', jiraUsername)
-  await appendToEnv(projectPath, 'JIRA_TOKEN', jiraApiToken)
-  logger.info('Stored Jira credentials in .env file')
-}
-
-export async function storeLicense(projectPath, license) {
-  await appendToEnv(projectPath, 'IMDONE_LICENSE', license)
-  logger.info('Stored license in .env file')
-}
-
-export async function init(projectPath) {
-  await initEnv(projectPath)
-  logger.info('Initialized .env file')
-}

package/src/adapters/git.js

@@ -1,113 +0,0 @@
-import { exec } from 'child_process'
-import { simpleGit } from 'simple-git'
-import { constants } from 'imdone-core/lib/constants.js'
-import { TAGS_FILE_PATH } from 'imdone-core/lib/adapters/storage/tags.js'
-import { access, appendFile } from 'fs/promises'
-import path from 'path'
-
-const { CONFIG_FILE_YML } = constants
-
-export async function isGitRepo(projectDir) {
-  try {
-    await access(path.join(projectDir, '.git'), constants.R_OK)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-export async function createRepo(projectDir) {
-  if (await isGitRepo(projectDir)) {
-    return
-  }
-  gitRepo(projectDir).init()
-}
-
-export async function appendToGitignore(projectDir, ignorePath) {
-  const gitignorePath = path.join(projectDir, '.gitignore')
-  await appendFile(gitignorePath, `${ignorePath}\n`, 'utf8')
-  await addAndCommitChanges(projectDir, `Append ${ignorePath} to .gitignore`, [".gitignore"]);
-}
-
-export async function isFileModified(projectDir, filePath) {
-    // run git diff --name-only <file> || git diff --cached --name-only <file>
-    return new Promise((resolve, reject) => {
-        exec(`cd "${projectDir}" && git diff --name-only "${filePath}" || git diff --cached --name-only "${filePath}"`, (error, stdout, stderr) => {
-            if (error) {
-                console.error(`exec error: ${error}`);
-                reject(error);
-            } else {
-                resolve(stdout.trim() !== '');
-            }
-        });
-    });
-}
-
-export async function isImdoneInit(projectPath) {
-    const git = gitRepo(projectPath)
-    const status = await git.status()
-    if (status.isClean()) {
-      return false
-    }
-    const { files } = status
-    const configFile = files.find(file => file.path === CONFIG_FILE_YML)
-    const tagsFile = files.find(file => file.path === TAGS_FILE_PATH)
-    return configFile || tagsFile
-}
-
-export async function gitIgnoreExists(projectPath, ignorePath) {
-  const git = gitRepo(projectPath)
-  const ignored = await git.checkIgnore([ignorePath])
-
-  return ignored.length > 0
-}
-
-export async function hasLocalChanges(projectPath) {
-  const git = gitRepo(projectPath)
-  const status = await git.status()
-  return status?.files?.length > 0
-}
-
-export async function expectNoChanges(projectPath, message) {
-  if (await hasLocalChanges(projectPath)) {
-      throw new Error(`There are modified files. Commit or stash your changes before ${message}.`)
-  }
-}
-
-export async function addAndCommitChanges(projectPath, message, add = ['.']) {
-  const git = gitRepo(projectPath)
-  const files = await status()
-  if (files.length === 0) {
-    return
-  }
-  const toAdd = add.includes('.') ? add : add.filter(file => files.some(f => f.path === file))
-  if (toAdd.length === 0) {
-    return
-  }
-  await git.add(toAdd)
-  await git.commit(message)
-}
-
-export async function stashChanges(projectPath) {
-  const git = gitRepo(projectPath)
-  await git.stash(['push', '-m', `imdone-with-jira-${new Date().toISOString()}`]);
-}
-
-export async function stashPop(projectPath) {
-  const git = gitRepo(projectPath)
-  await git.stash(['pop']);
-  const { files } = await git.status()
-  return files
-}
-
-export async function status(projectPath) {
-  const git = gitRepo(projectPath)
-  const { files } = await git.status()
-  return files
-}
-
-export function gitRepo(projectPath) {
-  const git = simpleGit({ baseDir: projectPath })
-  return git
-}
-  

package/src/adapters/imdone-config-template.js

@@ -1,79 +0,0 @@
-export function getImdoneConfigTemplate({name, jiraUrl, jql, jiraProjectKey}) {
-  return `keepEmptyPriority: true
-code:
-  include_lists:
-    - TODO
-    - DOING
-    - DONE
-    - PLANNING
-    - FIXME
-    - ARCHIVE
-    - HACK
-    - CHANGED
-    - XXX
-    - IDEA
-    - NOTE
-    - REVIEW
-    - BACKLOG
-lists:
-  - name: TODO
-    hidden: false
-    ignore: false
-  - name: DOING
-    hidden: false
-    ignore: false
-  - name: DONE
-    hidden: false
-    ignore: true
-settings:
-  openIn: code
-  openCodeIn: default
-  journalType: New File
-  journalPath: current-sprint
-  newCardSyntax: HASHTAG
-  replaceSpacesWith: '-'
-  plugins:
-    JiraPlugin:
-      jql: ${jql}
-      issueType: Story
-      projectKeys:
-        - key: ${jiraProjectKey}
-      statuses:
-        - jira: To Do
-          list: TODO
-        - jira: In Progress
-          list: DOING
-        - jira: Done
-          list: DONE
-      url: '${jiraUrl}'
-      defaultList: DOING
-      defaultDirectory: current-sprint
-    devMode: false
-  journalTemplate: null
-  markdownOnly: false
-  kudosProbability: 0.33
-  name: ${name}
-  views: []
-  cards:
-    colors: []
-    template: ''
-    trackChanges: false
-    metaNewLine: true
-    addCompletedMeta: true
-    addCheckBoxTasks: false
-    doingList: DOING
-    doneList: DONE
-    tokenPrefix: '#'
-    taskPrefix: '#'
-    tagPrefix: '#'
-    metaSep: ':'
-    orderMeta: true
-    maxLines: 3
-    addNewCardsToTop: true
-    showTagsAndMeta: false
-    addStartedMeta: false
-    defaultList: TODO
-    archiveCompleted: true
-    archiveFolder: archive
-`
-};

package/src/adapters/imdone.js

@@ -1,76 +0,0 @@
-import { logger } from 'imdone-core/lib/adapters/logger.js'
-import { createFileSystemProject } from 'imdone-core/lib/project-factory.js'
-import { constants } from 'imdone-core/lib/constants.js'
-import { load, isImdoneProject } from 'imdone-core/lib/adapters/storage/config.js'
-import { isImdoneInit, addAndCommitChanges } from './git.js'
-import { appendFile } from 'fs/promises'
-import path from 'path'
-import { getImdoneConfigTemplate } from './imdone-config-template.js'
-import JiraPlugin from '../../../main.js'
-import { TAGS_FILE_PATH } from 'imdone-core/lib/adapters/storage/tags.js'
-import { preparePathForWriting, writeFile } from 'imdone-core/lib/adapters/file-gateway.js'
-const { CONFIG_FILE_YML, IGNORE_FILE } = constants
-
-export async function getConfigPath(projectPath) {
-  const configPath = path.join(projectPath, CONFIG_FILE_YML)
-  return configPath
-}
-
-export async function getProject(projectPath, feedback = {}) {
-  if (!await isImdoneProject(projectPath)) {
-    throw new Error(`Project is not initialized. Run "imdone init" to initialize the project.`)
-  }
-  const config = await load(projectPath)
-  const project = createFileSystemProject({
-    path: projectPath,
-    config
-  })
-  project.toast = ({message}) => feedback.text = message
-  project.snackBar = ({message}) => feedback.text = message
-
-  project.emit = function(event, opts = {}) {
-    const { message, type, duration } = opts
-    logger.info(event, { message, type, duration })
-  }
-  await project.init()
-
-  if (await isImdoneInit(projectPath)) {
-    await addAndCommitChanges(projectPath, 'Initial commit', [CONFIG_FILE_YML, TAGS_FILE_PATH])
-  }
-
-  const jiraPlugin = await project.pluginManager.createPlugin(JiraPlugin)
-  const { pullFromJiraAction, pushToJiraAction } = jiraPlugin
-  return { 
-    project, 
-    jiraPlugin: {
-      pullFromJiraAction,
-      pushToJiraAction
-    }
-  }
-}
-
-export async function initProject(projectPath, {
-  name,
-  jiraUrl,
-  jiraProjectKey,
-  jql
-}) {
-  const configContent = getImdoneConfigTemplate({
-    name,
-    jiraUrl,
-    jiraProjectKey,
-    jql
-  })
-
-  const configPath = getConfigPath(projectPath)
-  await preparePathForWriting(configPath)
-  await writeFile(configPath, configContent, 'utf8')
-  await getProject(projectPath)
-}
-
-export async function appendToImdoneIgnore(projectPath, ignorePath) {
-  const imdoneIgnorePath = path.join(projectPath, IGNORE_FILE)
-  await appendFile(imdoneIgnorePath, `${ignorePath}\n`, 'utf8')
-  await addAndCommitChanges(projectPath, `Append ${ignorePath} to ${IGNORE_FILE}`, [IGNORE_FILE])
-}
-

package/src/adapters/license.js

@@ -1,83 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import jwt from 'jsonwebtoken';
-import path from 'node:path';
-
-const DIRNAME = path.dirname(import.meta.url);
-const PUBLIC_KEY_PATH = path.join(DIRNAME, 'jwt-public.pem');
-
-export const DEFAULT_PAYLOAD = {
-  name: undefined,
-  email: undefined,
-  org: undefined,
-  plan: "premium",
-  expiresIn: '30d',
-}
-
-export async function generateLicense(payload, privateKeyPath) {
-  // Apply default values to payload
-  const finalPayload = { ...DEFAULT_PAYLOAD, ...payload };
-
-  // throw an exception if the payload is missing required fields
-  const requiredFields = ['name', 'email', 'org', 'plan', 'expiresIn'];
-  for (const field of requiredFields) {
-    if (!finalPayload[field]) {
-      throw new Error(`Missing required field: ${field}`);
-    }
-  }
-
-  // Check if the payload has any extra fields
-  const extraFields = Object.keys(finalPayload).filter(field => !DEFAULT_PAYLOAD.hasOwnProperty(field));
-  if (extraFields.length > 0) {
-    throw new Error(`Extra fields found in payload: ${extraFields.join(', ')}`);
-  }
-  
-  const { expiresIn } = finalPayload;
-  delete finalPayload.expiresIn; // Remove expiresIn from payload
-
-  const privateKey = await readFile(privateKeyPath, 'utf8');
-  return jwt.sign(finalPayload, privateKey, {
-    algorithm: 'RS256',
-    expiresIn,
-  });
-}
-
-export async function verifyLicense(token, publicKeyPath = PUBLIC_KEY_PATH) {
-  try {
-    const publicKey = await readFile(publicKeyPath, 'utf8');
-    const decoded = jwt.verify(token, publicKey, {
-      algorithms: ['RS256'],
-    });
-    return { valid: true, data: License.fromPayload(decoded) };
-  } catch (err) {
-    return { valid: false, reason: err.message };
-  }
-}
-
-export class License {
-  constructor({name, email, org, plan, created, expires}) {
-    this.name = name;
-    this.email = email;
-    this.org = org;
-    this.plan = plan;
-    this.created = created;
-    this.expires = expires;
-  }
-
-  static fromPayload(payload) {
-    return new License({
-      name: payload.name,
-      email: payload.email,
-      org: payload.org,
-      plan: payload.plan,
-      created: new Date(payload.iat * 1000),
-      expires: new Date(payload.exp * 1000),
-    });
-  }
-}
-
-export async function validateEnvLicense() {
-  const { IMDONE_LICENSE } = process.env;
-  return IMDONE_LICENSE
-    ? await verifyLicense(IMDONE_LICENSE)
-    : { valid: false, reason: 'No license found in environment variables.' };
-}

package/src/bin.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import ora from 'ora';
-import { pullFromJira, dependencies as pullDeps } from "./usecases/headless-pull-from-jira.js";
-import { pushToJira, dependencies as pushDeps } from "./usecases/headless-push-to-jira.js";
-import { logger, LogLevel } from 'imdone-core/lib/adapters/logger.js';
-import { gitRepoCheck, imdoneProjectCheck, dotEnvCheck, gitIgnoreCheck, promptForConfig, promptForLicense, checkLicense } from './ui/prompt.js';
-import { imdoneInit } from './usecases/init.js';
-import { verifyLicense } from './adapters/license.js';
-import { init as initEnv, storeLicense } from './adapters/env.js';
-// get the version from package.json
-import { version } from '../package.json';
-logger.setLevel(process.env.LOG_LEVEL || LogLevel.ERROR);
-
-async function pullCommand() {
-  const spinner = ora('Pulling issues from Jira...').start();
-    
-  try {
-    const { result } = await pullFromJira(process.cwd(), { ...pullDeps, feedback: spinner });
-    const { existing, added } = result
-    const message = existing.length > 0 || added.length > 0
-      ? `Pulled ${existing.length} existing and ${added.length} new issues from Jira`
-      : 'No issues to pull from Jira';
-    spinner.succeed(message);
-  } catch (error) {
-    spinner.fail(`Failed to pull issues from Jira: ${error.message}`);
-    logger.error(error.stack);
-    process.exit(1);
-  }
-}
-
-async function pushCommand() {
-  const spinner = ora('Pushing changes to Jira...').start();
-  try {
-    const { result } = await pushToJira(process.cwd(), { ...pushDeps, feedback: ora });
-    const message = result.length > 0 ? `Pushed ${result.length} changes to Jira` : 'No changes to push to Jira';
-    spinner.succeed(message);
-    result.forEach(res => {
-      console.log(res.url)
-    })
-  } catch (error) {
-    spinner.fail(`Failed to push changes to Jira: ${error.message}`);
-    logger.error(error.stack)
-    process.exit(1);
-  }
-}
-
-const program = new Command();
-
-program
-  .name('imdone')
-  .description('Imdone CLI to pull from and push to Jira')
-  .version(version);
-
-program
-  .command('pull')
-  .description('Pull issues from Jira')
-  .action(async () => {
-    await checkLicense();
-    await pullCommand();
-  });
-
-program
-  .command('push')
-  .description('Push changes to Jira')
-  .action(async () => {
-    await checkLicense();
-    await pullCommand();
-    await pushCommand();
-  });
-
-program
-  .command('init')
-  .description('Initialize Jira integration')
-  .option('--name [name]', 'Project name')
-  .option('--jira-url [jiraUrl]', 'Jira URL (e.g., https://your-domain.atlassian.net)')
-  .option('--jira-project-key [jiraProjectKey]', 'Jira project key (e.g., ABC)')
-  .option('--jira-username [jiraUsername]', 'Jira username (email)')
-  .option('--jira-api-token [jiraApiToken]', 'Jira API token')
-  .option('--jql [jql]', 'JQL query to fetch issues (e.g., Sprint in openSprints() and status != "Done")')
-  .action(async (options) => {
-    const projectPath = process.cwd();
-
-    try {
-      if (
-        !await gitRepoCheck(projectPath)
-        || !await gitIgnoreCheck(projectPath)
-        || !await dotEnvCheck(projectPath)
-        || !await imdoneProjectCheck(projectPath)
-      ) {
-        console.log('Configuration cancelled');
-        process.exit(1);
-      }
-    } catch (error) {
-      logger.error('Imdone initialization failed:', error);
-      process.exit(1);
-    }
-
-    const config = await promptForConfig(options);
-    
-    const spinner = ora('Initializing imdone...').start();
-    
-    try {
-      await imdoneInit(projectPath, config);
-      spinner.succeed(`Imdone initialization for "${config.name}" completed successfully`);
-    } catch (error) {
-      spinner.fail(`Imdone initialization failed: ${error.message}`);
-      logger.error(error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('license')
-  .description('Enter or update your Imdone license')
-  .option('--token [token]', 'License token')
-  .option('--show', 'Show current license information')
-  .action(async (options) => {
-    const projectPath = process.cwd();
-    
-    if (options.show) {
-      const spinner = ora('Fetching license information...').start();
-      try {
-        const licenseCheck = await verifyLicense(process.env.IMDONE_LICENSE);
-        if (licenseCheck.valid) {
-          const { name, email, expires } = licenseCheck.data
-          spinner.succeed(`Current license: ${name} (${email}) - Expires: ${expires.toLocaleDateString()}`);
-        } else {
-          spinner.fail(`Invalid or expired license: ${licenseCheck.reason}`);
-        }
-      } catch (error) {
-        spinner.fail(`Failed to fetch license information: ${error.message}`);
-        logger.error(error);
-      }
-      return;
-    }
-
-    let licenseToken = options.token;
-    
-    // If no token provided via command line, prompt for it
-    if (!licenseToken) {
-      licenseToken = await promptForLicense();
-    }
-    
-    const spinner = ora('Validating license...').start();
-    
-    try {
-      // Verify the license is valid before storing it
-      const licenseCheck = await verifyLicense(licenseToken);
-      
-      if (!licenseCheck.valid) {
-        spinner.fail(`Invalid license: ${licenseCheck.reason}`);
-        process.exit(1);
-      }
-      
-      // License is valid, store it
-      await storeLicense(projectPath, licenseToken);
-      
-      const { name, email, expires } = licenseCheck.data
-      spinner.succeed(`License accepted for ${name} (${email}) - Expires: ${expires.toLocaleDateString()}`);
-    } catch (error) {
-      spinner.fail(`Failed to validate or store license: ${error.message}`);
-      logger.error(error);
-      process.exit(1);
-    }
-  });
-
-(async function main() {
-  await initEnv(process.cwd());
-  program.parse();  
-})();
-

package/src/index.js

@@ -1,3 +0,0 @@
-export { pullFromJira } from './usecases/headless-pull-from-jira.js'
-export { pushToJira } from './usecases/headless-push-to-jira.js'
-export { imdoneInit } from './usecases/init.js'