imdone-core 1.45.1 → 1.46.0

package/lib/cli/adapters/StorageAdapter.js

@@ -1,135 +0,0 @@
-const simpleGit = require('simple-git')
-const {changesExistError, ChangesExistError} = require('./Errors')
-
-module.exports =  class {
-
-  constructor(project) {
-    this.project = project
-    this.git = simpleGit(this.path)
-  }
-  
-  get path() {
-    return this.project.path
-  }
-
-  get remote() {
-    return this.pluginConfig.remote
-  }
-
-  get defaultBranch() {
-    return this.pluginConfig.defaultBranch
-  }
-
-  get pluginConfig() {
-    return this.project.config.settings.plugins.CliBacklogPlugin
-  }
-
-  async initTaskUpdate(task) {
-    if (await this.changesExist()) {
-      throw new ChangesExistError('start a task')
-    }
-
-    await this.checkoutStoryBranch({task})
-  }
-
-  async commitTaskUpdate(task) {
-    const taskBranchName = this.getTaskBranchName(task)
-    await this.project.addMetadata(task, 'branch', taskBranchName)
-    await this.git.add('.').commit(`Update task ${this.getTaskName(task)}`)
-    await this.git.push(this.remote)
-    await this.git.checkoutBranch(taskBranchName, this.getStoryBranchName({task}))
-  }
-
-  async initStoryPlan(storyId) {
-    if (await this.changesExist()) {
-      throw new ChangesExistError('plan a story')
-    }
-
-    await this.checkoutStoryBranch({storyId})
-  }
-
-  async saveStoryPlan(storyId) {
-    const storyBranchName = this.getStoryBranchName({storyId})
-    await this.git.add('.').commit(`Update story ${storyId}`)
-    await this.git.push(this.remote)
-  }
-
-  getTaskName(task) {
-    return this.project.getTaskName(task)
-  }
-
-  getStoryId(task) {
-    return this.project.getStoryId(task)
-  }
-  
-  getStoryBranchName({task, storyId}) {
-    return `${this.getStoryBranchPrefix({task, storyId})}/main`
-  }
-
-  getStoryBranchPrefix({task, storyId}) {
-    return `story/${storyId || this.getStoryId(task)}`
-  }
-
-  getTaskBranchName(task) {
-    const storyBranchPrefix = this.getStoryBranchPrefix({task})
-    const taskName = this.getTaskName(task)
-    return `${storyBranchPrefix}/task/${taskName}`
-  }
-
-  async getCurrentTask() {
-    const currentBranch = await this.getCurrentBranch()
-    const tasks = this.project.getTasks(`meta.branch="${currentBranch}"`)
-    return tasks && tasks.length == 1 && tasks[0]
-  }
-
-  async getCurrentBranch() {
-    return (await this.git.branchLocal()).current
-  }
-  
-  async changesExist() {
-    return !(await this.git.status()).isClean()
-  }
-
-  async checkoutDefaultBranch() {
-    const defaultBranch = this.defaultBranch
-    await this.fetch()
-    await this.git.checkout(defaultBranch)
-    await this.pull()
-  }
-
-  async checkoutStoryBranch({task, storyId}) {
-    const storyBranchName = this.getStoryBranchName({task, storyId})
-    
-    await this.checkoutDefaultBranch()
-    
-    if (await this.branchExists(storyBranchName)) {
-      await this.git.checkout(storyBranchName)
-      await this.pull()
-    } else {
-      await this.git.checkoutBranch(
-        storyBranchName,
-        this.defaultBranch
-      )
-      await this.pushNewBranch(storyBranchName)
-    }
-    await this.git.merge([this.defaultBranch])
-  }
-
-  async branchExists(branchName) {
-    const branches = await this.git.branchLocal()
-    return branches.all.includes(branchName)
-  }
-
-  async pull() {
-    await this.git.pull(this.remote)
-  }
-
-  async fetch() {
-    await this.git.fetch(this.remote)
-  }
-
-  async pushNewBranch(branchName) {
-    await this.git.push(this.remote, branchName, {'--set-upstream': null})
-  }
-
-}

package/lib/cli/domain/BacklogProject.js

@@ -1,170 +0,0 @@
-const { createFileSystemProject } = require('../../project-factory')
-const { resolve } = path = require('path')
-const STORIES_DIR = 'stories'
-const STORY_ID = 'story-id'
-const TASK_ID = 'task-id'
-const TODO = 'TODO'
-const DOING = 'DOING'
-const DONE = 'DONE'
-const ORDER = 'order'
-const UNGROUPED_TASKS = 'Ungrouped Tasks'
-
-class BacklogProject {
-  constructor(projectPath, config, ApplicationContext = require('../adapters/ApplicationContext')) {
-    this.ApplicationContext = ApplicationContext
-    this.StorageAdapter = ApplicationContext().StorageAdapter
-    this.projectPath = resolve(projectPath)
-    this._config = config
-    this.project = null
-  }
-
-  get path() {
-    return this.projectPath
-  }
-  
-  get name() {
-    return this.project.name
-  }
-
-  get defaultList() {
-    return this.config.getDefaultList()
-  }
-
-  get config() {
-    return this.project && this.project.config || this._config
-  }
-
-  async init() {
-    this.project = createFileSystemProject({path: this.projectPath, config: this.config})
-    await this.project.init()
-    this.storageAdapter = new this.StorageAdapter(this)
-    return this
-  }
-
-  getStoryProjectPath(storyId) {
-    return getStoryProjectPath(this.path, storyId)
-  }
-
-  async addStory(content) {
-    await this.addTaskToFile({list: TODO, content })
-  }
-
-  toStoryId(text) {
-    return this.project.sanitizeFileName(text)
-  }
-
-  removeList(list) {
-    return this.project.removeList(list)
-  }
-
-  getStoryIds() {
-    return [
-      ...new Set(
-        this.project.getCards(`meta.${STORY_ID}=* AND tags=story`).map(({meta, text, list}) => ({text, list, storyId: meta[STORY_ID][0]}))
-      )
-    ]
-  }
-
-  tasksToJson(tasks) {
-    return tasks.map(({text, type, list, meta, content, tags, context, description, source, beforeText, order}) => 
-      ({
-        list,
-        type,
-        order,
-        path: source.path,
-        prefix: beforeText,
-        text,
-        content,
-        description,
-        tags,
-        context,
-        meta
-      })
-    )
-  }
-  
-  getTaskName(task) {
-    return this.toStoryId(task.text)
-  }
-  
-  async startTask(taskId) {
-    await this.init()
-    
-    const taskFilter = `meta.${TASK_ID}="${taskId}"`
-    const task = this.project.getAllCards(taskFilter)[0]
-    if (!task) throw new Error(`No task found with id ${taskId}`)
-    
-    const storyId = task.meta[STORY_ID][0]
-    const storyFilter = `tags=story AND meta.${STORY_ID}="${storyId}"`
-    const story = this.project.getAllCards(storyFilter)[0]
-    
-    await this.storageAdapter.initTaskUpdate(task)
-    await this.moveTask(task, DOING, 0)
-    await this.project.addMetadata(task, 'branch', this.storageAdapter.getTaskBranchName(task))
-    this.project.rollBackFileForTask(task)
-    await this.moveTask(story, DOING, 0)
-    await this.storageAdapter.commitTaskUpdate(task)
-  }
-
-  async saveStory(storyId) {
-    // // Switch to the story branch or create it
-    // await git.checkout(storyBranchName);
-    // await git.pull('origin', storyBranchName, { '--force': null });
-
-    // // Push the changes to the story branch with force
-    // await git.push('origin', storyBranchName, { '--force': null });
-
-    // // Return to the original branch
-    // await git.checkout(currentBranch);
-
-    // Merge the story branch into the current branch
-
-  }
-
-  async moveTask(task, list, order) {
-    return await this.project.moveTask(task, list, order)
-  }
-
-  async addTaskToFile({path, list, tags, content, meta, contexts=[]}) {
-    return await this.project.addTaskToFile({path, list, tags, content, meta, contexts, useCardTemplate: true})
-  }
-
-  async addMetadata(task, key, value) {
-    return await this.project.addMetadata(task, key, value)
-  }
-
-  getCurrentStoryId() {
-    const tasks = this.project.getAllCards(`tags = "story" AND list = "${DOING}"`)
-    if (tasks.length < 1) return
-    return this.getStoryId(tasks[0])
-  }
-
-  getStoryId(task) {
-    return task.meta[STORY_ID][0]
-  }
-
-  async getCurrentTask() {
-    return await this.storageAdapter.getCurrentTask()
-  }
-}
-
-function getStoryProjectPath(projectPath, storyId) {
-  return path.join(projectPath, STORIES_DIR, storyId)
-}
-
-BacklogProject.getStoryProjectPath = getStoryProjectPath
-BacklogProject.createAndInit = async function(projectPath, config, ApplicationContext) {
-  return (await (new BacklogProject(projectPath, config, ApplicationContext)).init())
-}
-
-BacklogProject.constants = {
-  STORIES_DIR,
-  STORY_ID,
-  TASK_ID,
-  TODO,
-  DOING,
-  DONE,
-  ORDER,
-  UNGROUPED_TASKS
-}
-module.exports = BacklogProject

package/lib/cli/domain/StoryProject.js

@@ -1,67 +0,0 @@
-const path = require('path')
-const BacklogProject = require('./BacklogProject')
-const {
-  STORY_ID,
-  TASK_ID,
-  DONE,
-  DOING,
-  UNGROUPED_TASKS
-} = BacklogProject.constants
-
-class StoryProject extends BacklogProject {
-  constructor(projectPath, config, storyId, ApplicationContext = require('../adapters/ApplicationContext')) {
-    super(BacklogProject.getStoryProjectPath(projectPath, storyId), config, ApplicationContext)
-    this.storyId = storyId
-  }
-
-  async addTask({content, group = UNGROUPED_TASKS}) {
-    const file = await this.addTaskToFile({list: this.defaultList, content})
-    file.rollback().extractTasks(this.config)
-    const task = file.tasks[0]
-    if (group !== UNGROUPED_TASKS) {
-      await this.project.removeMetadata(task, 'group', UNGROUPED_TASKS)
-      await this.project.addMetadata(task, 'group', group)
-    }
-    return file.tasks[0]
-  }  
-
-  async completeTask() {
-    const task = await this.getCurrentTask()
-    if (!task) throw new Error('No current task')
-    await this.project.moveTask(task, DONE)
-    return task
-  }
-
-  getTaskId(task) {
-    return task.meta[TASK_ID][0]
-  }
-
-  getTaskName(task) {
-    const ext = path.extname(task.file.path)
-    return path.basename(task.file.path, ext)
-  }
-
-  getTasks(filter) {
-    filter = filter ? ` AND ${filter}` : ''
-    return this.project.getAllCards('tags=task' + filter)
-  }
-
-  getTask(taskId) {
-    return this.project.getCards(`tags=task AND meta.${TASK_ID}="${taskId}"`)[0]
-  }
-
-  getStory() {
-    return this.project.getAllCards(`tags=story`)[0]
-  }
-
-  get name() {
-    return this.project.name
-  }
-
-}
-
-StoryProject.createAndInit = async function(projectPath, config, storyId, ApplicationContext) {
-  return (await (new StoryProject(projectPath, config, storyId, ApplicationContext)).init())
-}
-
-module.exports = StoryProject

package/lib/cli/prompts/MarkdownPlanPrompt.js

@@ -1,16 +0,0 @@
-const defaultStory = `# Story Title
-
-Story description
-`
-module.exports.promptForMarkdownPlan = async function () {
-  const editor = (await import('@inquirer/editor')).default
-
-  return await editor({
-    message: 'Enter the story title and description markdown',
-    validate: function (text) {
-      if (!text) return 'Please enter a description'
-      return true
-    },
-    default: defaultStory  
-  });
-}

package/lib/plugins/cli-backlog-plugin.js

@@ -1,152 +0,0 @@
-const Plugin = require('imdone-api')
-const eol = require('eol')
-const _path = require('path')
-const {
-  dirname
-} = require('path')
-const { rmdir } = require('fs').promises
-const {
-  UNGROUPED_TASKS,
-  STORY_ID,
-  ORDER
-} = require('../cli/domain/BacklogProject').constants
-const { newStoryProject } = require('../cli/ProjectConfigFactory')
-
-
-const generateRandomString = (length) => {
-  let result = '';
-  const characters =
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-  const charactersLength = characters.length;
-  for (let i = 0; i < length; i++) {
-    result += characters.charAt(Math.floor(Math.random() * charactersLength));
-  }
-  return result;
-};
-
-const PROJECT_TYPES = {
-  BACKLOG_PROJECT: 'BACKLOG_PROJECT',
-  STORY_PROJECT: 'STORY_PROJECT'
-}
-
-module.exports = class CliBacklogPlugin extends Plugin {
-  get projectType() {
-    return this.getSettings().projectType
-  }
-
-  get isStoryProject() {
-    return this.projectType === PROJECT_TYPES.STORY_PROJECT
-  }
-
-  get isBacklogProject() { 
-    return this.projectType === PROJECT_TYPES.BACKLOG_PROJECT
-  }
-
-  get cardActionsMethod() {
-    return this.isStoryProject 
-      ? this.getStoryProjectCardActions
-      : this.isBacklogProject
-      ? this.getBacklogProjectCardActions
-      : () => []
-  }
-
-  get boardActionsMethod() {
-    return this.isStoryProject 
-      ? this.getStoryProjectBoardActions
-      : this.isBacklogProject
-      ? this.getBacklogProjectBoardActions
-      : () => []
-
-  }
-
-  async onBeforeAddTask({path, list, meta, tags, contexts, content}) {
-    if (!this.isBacklogProject) return {path, content, meta, tags, contexts}
-    const project = this.project
-    const storyId = project.sanitizeFileName(eol.split(content)[0])
-    const storyProject = await newStoryProject({projectPath: project.path, storyId})
-    path = _path.join(storyProject.path, 'README.md')
-    meta.push({key: STORY_ID, value: storyId})
-    meta.push({key: ORDER, value: 0})
-    return {path, content, meta, tags, contexts}
-  }
-
-  async onAfterDeleteTask(task) {
-    if (!this.isBacklogProject) return
-    const project = this.project
-    await rmdir(dirname(task.fullPath), {recursive: true})
-  }
-
-  getStoryProjectBoardActions() {
-    const project = this.project
-    
-    const groups = [...new Set(
-      project.getCards('meta.group = *').map((card) => card.meta.group && card.meta.group[0])
-    )].map(group => {
-      const name = group
-      const value = `"${group}"`
-      return { name, value}
-    })
-    const groupActions = [{name: 'All tasks', value: '*'}, ...groups].map(({name, value}) => {
-      const filterValue = encodeURIComponent(`meta.group = ${value} and tags = task`)
-      return {
-        name,
-        action: function () {
-          project.openUrl(`imdone://active.repo?filter=${filterValue}`)
-        }
-      }
-    })
-    const storyId = project.getAllCards('meta.story-id = *')[0].meta['story-id'][0]
-    const storiesDir = _path.dirname(project.path)
-    const backlogDir = _path.dirname(storiesDir)
-    const showStoryAction = {
-      name: 'Show story',
-      action: function () {
-        const query = encodeURIComponent(`allMeta.story-id="${storyId}"`)
-        project.openUrl(`imdone://${backlogDir}?filter=${query}`) // imdone:///Users/jesse/projects/imdone-projects/imdone-core/backlog?filter=allMeta.story-id="Board-action-to-show-backlog-from-story-project"
-      }
-    }
-
-    return [showStoryAction, ...groupActions]
-  }
-
-  getBacklogProjectBoardActions() {
-    return []
-  }
-
-  getStoryProjectCardActions(card) {
-    return []
-  }
-
-  getBacklogProjectCardActions(card) {
-    const fullPath = card.fullPath
-    const project = this.project
-    const storyProjectPath = dirname(fullPath)
-    const title = `Open story tasks`
-    return card.tags.includes('story') ? [
-      {
-        action: function () {
-          project.openUrl(`imdone://${storyProjectPath}`)
-        },
-        pack: 'fas',
-        icon: 'check-square',
-        title
-      }
-    ] : []
-  } 
-
-  getCardActions(card) {
-    return this.cardActionsMethod(card)
-  }
-
-  getBoardActions() {
-    return this.boardActionsMethod()
-  }
-
-  getCardProperties(task) {
-    return {
-      sid: generateRandomString(5),
-      projectName: this.project.name,
-      ungroupedTasks: UNGROUPED_TASKS
-    }
-  }
-}