imdone-cli 0.1.0

package/dist/jwt-public.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAztGTqz0skWsaknTnXIEL
+7Vi/BAAnJZf7NH4mAypIf4Dn6YZjwjdpNfdW+RzWxwaW0oyzGyIf2uuRrScAcnka
+0uaAWDjHqB7ghiqm41/5GmIbtmXWTa2QHamhYak5Wa/grprrwzaRY4dfHE/3n1N+
+B4lbeWw8Ga5hiRAWnKT9SkkyaYdHICeiewo03xSjkMs4+tg9kiHl+v32vRA7lVfz
+u4+GaAWjVS8/FRLF98wZWi0xCnaHLvdTIOl1PtUZXnrN5Bt8lcKwwqjxIRLiFn8B
+GUjIHIEMDwoxzfd+y6jWH9qEMo7qfJGyiti6w6EmHfz/UoOmDAh4lWq1kJNBqkAQ
+FwIDAQAB
+-----END PUBLIC KEY-----

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "imdone-cli",
+  "version": "0.1.0",
+  "author": "Jesse Piascik",
+  "description": "An imdone cli that automates your task updates with markdown files.",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "imdone": "dist/index.cjs"
+  },
+  "scripts": {
+    "prepublishOnly": "npm --prefix ../ install && npm --prefix ../ run build && npm i && npm test && npm run build",
+    "link": "npm link ../../imdone-core-2 ../../imdone-api",
+    "build": "node esbuild.config.js && cp public/* dist/",
+    "coverage": "vitest --run --coverage",
+    "test": "vitest --run",
+    "test-ci": "vitest --run"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "dotenv": "16.4.5",
+    "imdone-core": "^2.0.8",
+    "inquirer": "^12.5.2",
+    "jsonwebtoken": "^9.0.2",
+    "ora": "^8.2.0",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.2",
+    "esbuild-plugin-copy": "^2.1.1",
+    "vitest": "^3.1.1"
+  }
+}

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

@@ -0,0 +1,11 @@
+#!/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

@@ -0,0 +1,28 @@
+-----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

@@ -0,0 +1,9 @@
+-----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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,71 @@
+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, getConfigPath, 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 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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,164 @@
+#!/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';
+
+logger.setLevel(process.env.LOG_LEVEL || LogLevel.ERROR);
+
+const program = new Command();
+
+program
+  .name('imdone')
+  .description('Imdone CLI to pull from and push to Jira')
+  .version('1.0.0');
+
+program
+  .command('pull')
+  .description('Pull issues from Jira')
+  .action(async () => {
+    await checkLicense();
+    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);
+    }
+  });
+
+program
+  .command('push')
+  .description('Push changes to Jira')
+  .action(async () => {
+    await checkLicense();
+    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);
+    }
+  });
+
+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

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