@uss-stargazer/job-queue 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,33 @@
+# Job Queue
+
+The concept is modeling your todo-list as bite-sized jobs in a First-In, First-Out (FIFO) queue.
+The goal is to increase productivity.
+
+- Small jobs that do one thing at a time are more manageable, and make Git commits easier
+- Documenting todo in manageable fashion decreases liklihood of abandoning a project
+
+## Install
+
+Can be installed system-wide if you have Node/NPM installed:
+
+```
+npm install --global @uss-stargazer/job-queue
+```
+
+Then, you can use like:
+
+```
+job-queue --help
+# or 
+jobq --help
+```
+
+## Workflow
+
+- _\[Daemon\]_ Spontaneous, not fleshed out ideas get immediately added to the project pool as "inactive".
+- You should generally have an idea of a few projects you want to focus on at a time. For each, push
+  jobs to the jobqueue that do a **_single thing_** (ideally no more; they should be contained in a
+  single Git commit).
+- Work (while you haven't finished the projects you're focusing on)
+  - Go through job queue and remove jobs when complete (committing as you go).
+  - _\[Daemon\]_ While not on the terminal, think of next jobs, then push to queue.

package/dist/actions.js

@@ -0,0 +1,180 @@
+import chalk from 'chalk';
+import { confirm, search } from '@inquirer/prompts';
+import sortableCheckbox from './utils/sortableCheckbox.js';
+import { AbortError, reorder } from './utils/index.js';
+import { updateJob } from './data/jobqueue.js';
+import { updateProject } from './data/projectpool.js';
+export const actionNames = [
+    'dequeueJob',
+    'enqueueJob',
+    'editQueue',
+    'addProject',
+    'editProject',
+];
+export const actionsDependentOnJobs = ['dequeueJob', 'editQueue'];
+export const actionsDependentOnProjects = [
+    'enqueueJob',
+    'editProject',
+];
+const actions = {
+    dequeueJob: async ({ jobqueue, projectpool, config }) => {
+        const queue = jobqueue.data.queue;
+        const job = queue.shift();
+        if (job === undefined) {
+            console.log(chalk.red('[e]'), 'No jobs in queue.');
+            return;
+        }
+        try {
+            const updatedJob = await updateJob(job, projectpool, config.data);
+            if (updatedJob !== 'deleted') {
+                queue.unshift(updatedJob);
+                console.log(chalk.blue('[i]'), 'Job edited');
+            }
+            else {
+                console.log(chalk.green('✔'), 'Job completed and deleted');
+            }
+            await jobqueue.sync();
+        }
+        catch (error) {
+            if (!(error instanceof AbortError))
+                throw error;
+            console.log(chalk.red('[e]'), error.message);
+            queue.unshift(job);
+        }
+    },
+    enqueueJob: async ({ jobqueue, projectpool, config }) => {
+        if (projectpool.data.pool.length === 0) {
+            console.log(chalk.red('[e]'), 'No projects in pool to make job for.');
+            return;
+        }
+        const queue = jobqueue.data.queue;
+        const placeholderJob = {
+            name: '[placeholder]',
+            objectivies: [
+                'Put the thing in the thing.',
+                'Make sure that thing works.',
+            ],
+            project: '[some-project]',
+            updates: 'Put notes here.',
+        };
+        try {
+            const job = await updateJob(placeholderJob, projectpool, config.data);
+            if (job === 'deleted')
+                throw new AbortError('Enqueue aborted');
+            queue.push(job);
+            console.log(chalk.green('✔'), 'Job enqueued');
+            await jobqueue.sync();
+        }
+        catch (error) {
+            if (!(error instanceof AbortError))
+                throw error;
+            console.log(chalk.red('[e]'), error.message);
+        }
+    },
+    editQueue: async ({ jobqueue, projectpool, config }) => {
+        const queue = jobqueue.data.queue;
+        if (queue.length === 0) {
+            console.log(chalk.red('[e]'), 'No jobs in queue.');
+            return;
+        }
+        const reorderedQueueIdxs = await sortableCheckbox({
+            message: 'Reorder queue and/or select jobs to edit',
+            choices: queue.map((job, jobIdx) => ({
+                name: `[${job.project}] ${job.name}`,
+                value: jobIdx,
+            })),
+        });
+        reorder(queue, reorderedQueueIdxs.map(({ value: jobIdx }) => jobIdx));
+        console.log(chalk.green('✔'), 'Queue reordered.');
+        const checkedActivities = reorderedQueueIdxs
+            .map(({ checked }, jobIdx) => ({ checked, jobIdx }))
+            .filter(({ checked }) => checked);
+        if (checkedActivities.length > 0) {
+            for (let checkedIdx = 0; checkedIdx < checkedActivities.length; checkedIdx++) {
+                const jobIdx = checkedActivities[checkedIdx].jobIdx;
+                try {
+                    const job = queue[jobIdx];
+                    const updatedJob = await updateJob(job, projectpool, config.data);
+                    if (updatedJob === 'deleted') {
+                        queue.splice(jobIdx, 1);
+                        console.log(chalk.green('✔'), `Job '${job.name}' deleted.`);
+                    }
+                    else {
+                        queue[jobIdx] = updatedJob;
+                        console.log(chalk.green('✔'), `Job '${updatedJob.name}' edited.`);
+                    }
+                    await jobqueue.sync();
+                }
+                catch (error) {
+                    if (!(error instanceof AbortError))
+                        throw error;
+                    console.log(chalk.red('[e]'), error.message);
+                    if (checkedIdx + 1 < checkedActivities.length &&
+                        (await confirm({ message: 'Abort all edits?' })))
+                        break;
+                }
+            }
+        }
+    },
+    addProject: async ({ jobqueue, projectpool, config }) => {
+        const pool = projectpool.data.pool;
+        const placeholderProject = {
+            name: '[some-project]',
+            description: 'This is a placeholder project.',
+            repo: 'https://some.project.com/project',
+            status: 'inactive',
+        };
+        try {
+            const project = await updateProject(placeholderProject, projectpool, jobqueue, config.data);
+            if (project === 'deleted')
+                throw new AbortError('Add project aborted');
+            pool.push(project);
+            console.log(chalk.green('✔'), 'Added new project');
+            await projectpool.sync();
+        }
+        catch (error) {
+            if (!(error instanceof AbortError))
+                throw error;
+            console.log(chalk.red('[e]'), error.message);
+        }
+    },
+    editProject: async ({ jobqueue, projectpool, config }) => {
+        const pool = projectpool.data.pool;
+        if (pool.length === 0) {
+            console.log(chalk.red('[e]'), 'No projects in pool.');
+            return;
+        }
+        const projectName = await search({
+            message: 'Enter the name of the project to edit',
+            source: (partialProjectName) => {
+                const projectNames = pool.map((project) => project.name);
+                if (!partialProjectName)
+                    return projectNames;
+                const partialSet = new Set([...partialProjectName]);
+                return projectNames.filter((projectName) => partialSet.isSubsetOf(new Set([...projectName])));
+            },
+        });
+        const projectIdx = pool.findIndex((project) => project.name === projectName);
+        if (projectIdx < 0)
+            throw new Error('Invalid project name');
+        const [project] = pool.splice(projectIdx, 1);
+        try {
+            const updatedProject = await updateProject(project, projectpool, jobqueue, config.data);
+            if (updatedProject !== 'deleted') {
+                pool.push(updatedProject);
+                console.log(chalk.green('✔'), 'Project edited');
+            }
+            else {
+                console.log(chalk.green('✔'), 'Project deleted');
+            }
+            await projectpool.sync();
+        }
+        catch (error) {
+            if (error instanceof AbortError)
+                throw error;
+            console.log(chalk.red('[e]'), error.message);
+            pool.push(project);
+        }
+    },
+};
+export default actions;

package/dist/data/config.js

@@ -0,0 +1,158 @@
+import * as z from 'zod';
+import envPaths from 'env-paths';
+import path from 'path';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { makeJsonData } from '../utils/jsonData.js';
+import chalk from 'chalk';
+import { JobQueueSchema, JobSchema } from './jobqueue.js';
+import { ProjectPoolSchema, ProjectSchema, } from './projectpool.js';
+import { confirm } from '@inquirer/prompts';
+import { fileURLToPath, pathToFileURL } from 'url';
+import pkg from '../../package.json' with { type: 'json' };
+const jsonSchemaNames = [
+    'job',
+    'jobqueue',
+    'project',
+    'projectpool',
+    'config',
+];
+const NonemptyString = z.string().nonempty();
+export const ConfigSchema = z.object({
+    jobqueue: NonemptyString.optional().meta({ title: "Jobqueue path", description: "Path to jobqueue.json." }),
+    projectpool: NonemptyString.optional().meta({ title: "Projectpool path", description: "Path to projectpool.json." }),
+    editor: NonemptyString.optional().meta({ title: "Editor command", description: "Command to run editor. Will be run like `<editor> /some/data.json` so make sure it waits." }),
+    schemas: NonemptyString.meta({ title: "Schemas directory", description: `Path to directory containing: ${jsonSchemaNames.map(base => `${base}.schema.json`).join(", ")}.` }).transform((schemasDir) => Object.fromEntries(jsonSchemaNames.map((base) => [base, pathToFileURL(path.resolve(schemasDir, `${base}.schema.json`)).href]))),
+});
+const jsonSchemas = {
+    job: JobSchema,
+    jobqueue: JobQueueSchema,
+    project: ProjectSchema,
+    projectpool: ProjectPoolSchema,
+    config: ConfigSchema,
+};
+const updateNestedObject = async (base, update) => {
+    const keys = [...Object.keys(update)];
+    for (const key of keys) {
+        if (typeof base[key] === 'object' &&
+            base[key] !== null &&
+            !Array.isArray(base[key])) {
+            await updateNestedObject(base[key], update[key]);
+        }
+        else {
+            const shouldUpdate = await confirm({
+                message: `Supplied '${key.toString()}' is different than in config. Want to update config?`,
+            });
+            if (shouldUpdate)
+                base[key] = update[key];
+        }
+    }
+};
+const getJsonSchemaId = (schemaFileUrl) => path.posix.join(pkg.version, path.basename(fileURLToPath(schemaFileUrl)));
+const versionFromJsonSchemaId = (id) => path.dirname(id);
+const updateJsonSchema = async (schemaSchema, schemaFileUrl) => {
+    const schemaPath = fileURLToPath(schemaFileUrl);
+    await fs.mkdir(path.dirname(schemaPath), { recursive: true });
+    return await fs.writeFile(schemaPath, JSON.stringify({
+        $id: getJsonSchemaId(schemaFileUrl),
+        ...schemaSchema.toJSONSchema({
+            io: 'input',
+            unrepresentable: 'throw',
+        }),
+    }, undefined, '  '));
+};
+const defaultData = {
+    jobqueue: { queue: [] },
+    projectpool: { pool: [] },
+};
+const createConfig = async (configDir, override) => {
+    const config = {
+        jobqueue: path.resolve(configDir, 'jobqueue.json'),
+        projectpool: path.resolve(configDir, 'projectpool.json'),
+        schemas: path.resolve(configDir, 'schemas'),
+        ...override,
+    };
+    const decodedConfig = ConfigSchema.decode(config);
+    for (const key of ['jobqueue', 'projectpool']) {
+        if (!existsSync(config[key])) {
+            console.log(chalk.blue('[i]'), `Creating ${path.join('{config}', path.relative(configDir, config[key]))}...`);
+            await fs.writeFile(config[key], JSON.stringify({
+                $schema: decodedConfig.schemas[key],
+                ...defaultData[key],
+            }, undefined, '  '));
+        }
+    }
+    await fs.mkdir(config.schemas);
+    for (const schema of jsonSchemaNames) {
+        if (!existsSync(decodedConfig.schemas[schema])) {
+            console.log(chalk.blue('[i]'), `Creating ${path.join('{config}', path.relative(configDir, fileURLToPath(decodedConfig.schemas[schema])))}...`);
+            await updateJsonSchema(jsonSchemas[schema], decodedConfig.schemas[schema]);
+        }
+    }
+    return { encoded: config, decoded: decodedConfig };
+};
+const checkConfig = async (config, configPath) => {
+    try {
+        for (const key of ['jobqueue', 'projectpool']) {
+            if (!existsSync(config[key]))
+                if (['jobqueue', 'projectpool'].includes(key) &&
+                    (await confirm({
+                        message: `File at config.${key} does not exist. Want to create it?`,
+                    })))
+                    await fs.writeFile(config[key], JSON.stringify({
+                        $schema: config.schemas[key],
+                        ...defaultData[key],
+                    }, undefined, '  '));
+                else
+                    throw new Error(`File '${config[key]}' in config does not exist`);
+        }
+        const outdatedSchemas = [];
+        for (const schema of Object.keys(config.schemas)) {
+            const schemaPath = fileURLToPath(config.schemas[schema]);
+            if (existsSync(schemaPath)) {
+                const schemaJson = JSON.parse(await fs.readFile(schemaPath, {
+                    encoding: 'utf8',
+                }));
+                const version = schemaJson.$id && versionFromJsonSchemaId(schemaJson.$id);
+                if (!version || !/^\d+\.\d+\.\d+$/.test(version)) {
+                    console.log(chalk.yellow('[w]'), `${path.join('{config}', path.basename(config.schemas[schema]))} is malformed. Overwriting...`);
+                    await updateJsonSchema(jsonSchemas[schema], config.schemas[schema]);
+                }
+                else if (version !== pkg.version) {
+                    outdatedSchemas.push(schema);
+                }
+            }
+            else {
+                console.log(chalk.blue('[i]'), `${path.join('{config}', path.basename(config.schemas[schema]))} does not exist. Creating...`);
+                await updateJsonSchema(jsonSchemas[schema], config.schemas[schema]);
+            }
+        }
+        if (outdatedSchemas.length > 0) {
+            const shouldUpdate = await confirm({
+                message: 'You are using at least one outdated JSON schema. Want to regenerate them?',
+            });
+            if (shouldUpdate)
+                outdatedSchemas.forEach((schema) => updateJsonSchema(jsonSchemas[schema], config.schemas[schema]));
+        }
+    }
+    catch (error) {
+        throw new Error(`${error}\nFix config at '${configPath}'.`);
+    }
+};
+export const getConfig = async (overrideConfigDir, overrideConfig) => {
+    const configDir = overrideConfigDir ?? path.resolve(envPaths('job-queue').config);
+    const configPath = path.resolve(configDir, 'config.json');
+    await fs.mkdir(configDir, { recursive: true });
+    if (!existsSync(configPath)) {
+        console.log(chalk.blue('[i]'), `Creating config at '${configPath}'...`);
+        const { encoded: config, decoded: decodedConfig } = await createConfig(configDir, overrideConfig);
+        await fs.writeFile(configPath, JSON.stringify({
+            $schema: decodedConfig.schemas['config'],
+            ...config,
+        }, undefined, '  '));
+    }
+    const configData = await makeJsonData(configPath, ConfigSchema);
+    await checkConfig(configData.data, configPath);
+    await updateNestedObject(configData.data, ConfigSchema.partial().decode(overrideConfig));
+    return configData;
+};

package/dist/data/index.js

@@ -0,0 +1,9 @@
+import { JobQueueSchema } from './jobqueue.js';
+import { ProjectPoolSchema } from './projectpool.js';
+import { ConfigSchema } from './config.js';
+export const dataNames = ['jobqueue', 'projectpool', 'config'];
+export const dataSchemas = {
+    jobqueue: JobQueueSchema,
+    projectpool: ProjectPoolSchema,
+    config: ConfigSchema,
+};

package/dist/data/jobqueue.js

@@ -0,0 +1,51 @@
+import * as z from 'zod';
+import { makeJsonData } from '../utils/jsonData.js';
+import { checkProjectName } from './projectpool.js';
+import { haveUserUpdateData } from '../utils/index.js';
+export const JobSchema = z.object({
+    name: z.string().trim().nonempty().meta({ title: 'Job name', description: 'Short name of the job (think a single commit message). Used as job identifier.' }),
+    objectivies: z.array(z.string().trim().nonempty()).meta({ title: 'Job objectivies', description: 'A list of objectives to complete for this job. Purely for your benefit.' }),
+    updates: z.string().optional().meta({ title: 'Job updates', description: "Put any notes/updates to the job here while you're working. Optional." }),
+    project: z.string().trim().nonempty().meta({ title: 'Associated project', description: 'Corresponding project ID in projectpool.json.' }),
+}).meta({ title: 'Job', description: 'A single job entry for JobQueue.' });
+export const JobQueueSchema = z.object({
+    queue: z.array(JobSchema).meta({ title: 'Job queue' }),
+}).meta({ title: 'Job queue root', description: 'Root object for jobs/tasks FIFO queue model.' });
+export const getJobQueue = async (jsonPath) => await makeJsonData(jsonPath, JobQueueSchema);
+export const updateJob = async (job, projectPool, config) => {
+    const pool = projectPool.data.pool;
+    let userDeletedJob = false;
+    const updatedJob = await haveUserUpdateData(JobSchema, job, {
+        editor: config.editor,
+        errorHead: 'Rejected job',
+        file: { type: 'tmp', prefix: 'jobqueue-job' },
+        tooltips: [
+            'Opening job JSON in editor for editing.',
+            'Delete file contents to finish the job.',
+        ],
+        jsonSchemaUrl: config.schemas.job,
+    }, {
+        preparse(rawContents) {
+            if (rawContents.trim().length === 0) {
+                userDeletedJob = true;
+                return 'pass';
+            }
+            return 'continue';
+        },
+        postparse(job) {
+            return checkProjectName(job.project, pool)
+                ? 'continue'
+                : {
+                    errMessage: `invalid project name: '${job.project}' not in project pool`,
+                };
+        },
+    });
+    if (!userDeletedJob) {
+        const jobProject = pool.find((project) => project.name === updatedJob.project);
+        if (jobProject.status !== 'active') {
+            jobProject.status = 'active';
+            await projectPool.sync();
+        }
+    }
+    return userDeletedJob ? 'deleted' : updatedJob;
+};

package/dist/data/projectpool.js

@@ -0,0 +1,65 @@
+import { confirm } from '@inquirer/prompts';
+import * as z from 'zod';
+import { makeJsonData } from '../utils/jsonData.js';
+import { haveUserUpdateData } from '../utils/index.js';
+export const ProjectSchema = z.object({
+    name: z.string().trim().nonempty().meta({ title: 'Project name', description: 'Name of the project. Used as identifier.' }),
+    description: z.string().optional().meta({ title: 'Project description', description: 'Longer description of the project. For your benefit, optional.' }),
+    repo: z.url().optional().meta({ title: 'Project repository', description: 'URL to project repository. For your benefit, optional.' }),
+    status: z.enum(['active', 'inactive', 'complete']).meta({ title: 'Project status', description: "Status of this project. 'active': they are referenced in jobqueue.json, 'inactive': they aren't referenced anywhere and aren't done, 'complete': they're done." }),
+}).meta({ title: 'Project', description: 'A single project entry for JobQueue (usually matches up with a GitHub repo, if you use that).' });
+export const ProjectPoolSchema = z.object({
+    pool: z.array(ProjectSchema).meta({ description: 'Set of projects, works in progress or just ideas.' }),
+}).meta({ title: 'Root project pool', description: 'Root object for pool of projects.' });
+export const getProjectPool = async (jsonPath) => await makeJsonData(jsonPath, ProjectPoolSchema);
+export const checkProjectName = (name, projects) => projects.some((project) => project.name === name);
+export const updateProject = async (project, projectPool, jobQueue, config) => {
+    const pool = projectPool.data.pool;
+    const jobsReferencingProject = jobQueue.data.queue.filter((job) => job.project === project.name);
+    let userDeletedProject = false;
+    const updatedProject = await haveUserUpdateData(ProjectSchema, project, {
+        editor: config.editor,
+        errorHead: 'Rejected project',
+        file: { type: 'tmp', prefix: 'jobqueue-project' },
+        tooltips: [
+            'Opening project JSON in editor for editing.',
+            'Delete file contents to delete the project.',
+        ],
+        jsonSchemaUrl: config.schemas.project,
+    }, {
+        preparse(rawContents) {
+            if (rawContents.trim().length === 0) {
+                userDeletedProject = true;
+                return 'pass';
+            }
+            return 'continue';
+        },
+        postparse(updatedProject) {
+            if (updatedProject.name !== project.name &&
+                checkProjectName(updatedProject.name, pool))
+                return {
+                    errMessage: `new name '${updatedProject.name}' already exists in pool`,
+                };
+            if (jobsReferencingProject.length > 0 &&
+                updatedProject.status !== 'active')
+                return {
+                    errMessage: `status can not be set to ${updatedProject.status}: jobs in queue still reference project`,
+                };
+            return 'continue';
+        },
+    });
+    if (!userDeletedProject &&
+        updatedProject.name !== project.name &&
+        jobsReferencingProject.length > 0) {
+        const renameJobReferences = await confirm({
+            message: `You are changing this project's name to ${updatedProject.name}. Would you like to rename the project entry in referencing jobs?`,
+        });
+        if (renameJobReferences) {
+            jobsReferencingProject.forEach((job) => {
+                job.project = updatedProject.name;
+            });
+            await jobQueue.sync();
+        }
+    }
+    return userDeletedProject ? 'deleted' : updatedProject;
+};

package/dist/index.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import clear from 'clear';
+import figlet from 'figlet';
+import { select } from '@inquirer/prompts';
+import { ExitPromptError } from '@inquirer/core';
+import actions, { actionNames, actionsDependentOnJobs, actionsDependentOnProjects, } from './actions.js';
+import { getConfig } from './data/config.js';
+import { getJobQueue } from './data/jobqueue.js';
+import { getProjectPool } from './data/projectpool.js';
+export default async function main(overrideConfigDir, overrideConfig) {
+    clear();
+    console.log(chalk.yellow(figlet.textSync('JobQueue', { horizontalLayout: 'full' })));
+    const config = await getConfig(overrideConfigDir, overrideConfig);
+    const data = {
+        config: config,
+        jobqueue: await getJobQueue(config.data.jobqueue),
+        projectpool: await getProjectPool(config.data.projectpool),
+    };
+    console.log();
+    try {
+        while (true) {
+            const action = await select({
+                message: 'Select action',
+                choices: actionNames.map((action) => {
+                    if (actionsDependentOnJobs.includes(action) &&
+                        data.jobqueue.data.queue.length === 0)
+                        return {
+                            name: action,
+                            value: action,
+                            disabled: '(Empty job queue)',
+                        };
+                    else if (actionsDependentOnProjects.includes(action) &&
+                        data.projectpool.data.pool.length === 0)
+                        return {
+                            name: action,
+                            value: action,
+                            disabled: '(Empty project pool)',
+                        };
+                    else
+                        return { name: action, value: action };
+                }),
+            });
+            await actions[action](data);
+            console.log();
+        }
+    }
+    catch (error) {
+        if (!(error instanceof ExitPromptError))
+            throw error;
+    }
+}

package/dist/utils/index.js

@@ -0,0 +1,83 @@
+import * as tmp from 'tmp-promise';
+import chalk from 'chalk';
+import * as z from 'zod';
+import { confirm } from '@inquirer/prompts';
+import { editInteractively } from 'edit-like-git';
+export class AbortError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export function reorder(array, newIndecies) {
+    if (array.length !== newIndecies.length)
+        throw new RangeError('Indecies array must be same length as target array');
+    const originalArray = [...array];
+    newIndecies.forEach((originalIdx, idx) => {
+        array[idx] = originalArray[originalIdx];
+    });
+}
+export const haveUserUpdateData = async (schema, data, options, checks) => {
+    const file = options?.file?.type && options.file.type === 'abs'
+        ? { path: options.file.path }
+        : await tmp.file({
+            prefix: options?.file?.type === 'tmp' ? options.file.prefix : undefined,
+            postfix: '.json',
+        });
+    let contents = JSON.stringify(schema instanceof z.ZodObject && options?.jsonSchemaUrl
+        ? { $schema: options?.jsonSchemaUrl, ...data }
+        : data, undefined, '  ');
+    let updatedResult = undefined;
+    while (true) {
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const editorPromise = editInteractively(file.path, contents, options?.editor, options?.tooltips);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const abortPromise = confirm({ message: 'Type `y` to abort...' }, { signal })
+            .finally(() => {
+            process.stdout.moveCursor(0, -1);
+            process.stdout.clearLine(1);
+        })
+            .then(async (shouldAbort) => {
+            if (shouldAbort) {
+                if (file.cleanup)
+                    await file.cleanup();
+                throw new AbortError('User aborted action');
+            }
+        });
+        contents = await Promise.race([editorPromise, abortPromise]);
+        controller.abort();
+        if (typeof contents !== 'string')
+            return undefined;
+        if (checks?.preparse) {
+            const preparseError = checks?.preparse(contents);
+            if (preparseError === 'pass') {
+                updatedResult = undefined;
+                break;
+            }
+            else if (typeof preparseError === 'object') {
+                console.log(chalk.red(`${options?.errorHead}:`), preparseError.errMessage);
+                continue;
+            }
+        }
+        updatedResult = schema.safeParse(JSON.parse(contents));
+        if (updatedResult.success) {
+            if (checks?.postparse) {
+                const postparseError = checks?.postparse(updatedResult.data);
+                if (typeof postparseError === 'object') {
+                    console.log(chalk.red(`${options?.errorHead}:`), postparseError.errMessage);
+                    continue;
+                }
+            }
+            break;
+        }
+        console.log(chalk.red(`${options?.errorHead}:`), `JSON invalid: ${updatedResult.error.message}`);
+    }
+    if (file.cleanup)
+        await file.cleanup();
+    return (updatedResult &&
+        (updatedResult.success
+            ? updatedResult.data
+            : (() => {
+                throw new Error(`${options?.errorHead}: JSON invalid: ${updatedResult.error.message}`);
+            })()));
+};

package/dist/utils/jsonData.js

@@ -0,0 +1,24 @@
+import fs from 'fs/promises';
+import * as z from 'zod';
+export const makeJsonData = async (jsonPath, schema) => {
+    const json = JSON.parse(await fs.readFile(jsonPath, 'utf8').catch((error) => {
+        throw new Error(`Couldn't open '${jsonPath}': ${error}`);
+    }));
+    const schemaUrl = json['$schema'];
+    const parsed = schema.safeParse(json);
+    if (!parsed.success)
+        throw new Error(`JSON at '${jsonPath}' does not match schema: ${z.treeifyError(parsed.error)}`);
+    const jsonData = {
+        data: parsed.data,
+        async sync() {
+            const encoded = schema.encode(jsonData.data);
+            return fs.writeFile(jsonPath, JSON.stringify(typeof schemaUrl === 'string'
+                ? {
+                    $schema: schemaUrl,
+                    ...encoded,
+                }
+                : encoded, undefined, '  '), 'utf8');
+        },
+    };
+    return jsonData;
+};

package/dist/utils/sortableCheckbox.js

@@ -0,0 +1,197 @@
+import { createPrompt, useState, useKeypress, usePrefix, usePagination, useRef, useMemo, makeTheme, isUpKey, isDownKey, isSpaceKey, isNumberKey, isEnterKey, ValidationError, } from '@inquirer/core';
+import chalk from 'chalk';
+import figures from '@inquirer/figures';
+import ansiEscapes from 'ansi-escapes';
+const checkboxTheme = {
+    icon: {
+        checked: chalk.green(figures.circleFilled),
+        unchecked: figures.circle,
+        cursor: figures.pointer,
+    },
+    style: {
+        disabledChoice: (text) => chalk.dim(`- ${text}`),
+        renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.name || choice.value).join(', '),
+    },
+    helpMode: 'auto',
+};
+export default createPrompt((config, done) => {
+    const { instructions, pageSize = 7, choices, required, validate = () => true, } = config;
+    const theme = makeTheme(checkboxTheme, config.theme);
+    const prefix = usePrefix({ theme });
+    const firstRender = useRef(true);
+    const [status, setStatus] = useState('pending');
+    const [items, setItems] = useState(choices.map((choice) => ({ ...choice })));
+    const bounds = useMemo(() => {
+        const first = items.findIndex(isSelectable);
+        const last = items.findLastIndex(isSelectable);
+        if (first < 0) {
+            throw new ValidationError('[checkbox prompt] No selectable choices. All choices are disabled.');
+        }
+        return { first, last };
+    }, [items]);
+    const [active, setActive] = useState(bounds.first);
+    const [showHelpTip, setShowHelpTip] = useState(true);
+    const [errorMsg, setError] = useState(undefined);
+    useKeypress(async (key) => {
+        if (isEnterKey(key)) {
+            const selection = items.filter(isChecked);
+            const isValid = await validate([...selection]);
+            if (required && !items.some(isChecked)) {
+                setError('At least one choice must be selected');
+            }
+            else if (isValid === true) {
+                setStatus('done');
+                done(items.map((choice) => ({
+                    value: choice.value,
+                    checked: choice.checked,
+                })));
+            }
+            else {
+                setError(isValid || 'You must select a valid value');
+            }
+        }
+        else if (isActivateNextItemKey(key) || isActivatePreviousItemKey(key)) {
+            if ((isActivatePreviousItemKey(key) && active !== bounds.first) ||
+                (isActivateNextItemKey(key) && active !== bounds.last)) {
+                const offset = isUpKey(key) ? -1 : 1;
+                let next = active;
+                do {
+                    next = (next + offset + items.length) % items.length;
+                } while (!isSelectable(items[next]));
+                setActive(next);
+            }
+        }
+        else if (isSpaceKey(key)) {
+            setError(undefined);
+            setItems(items.map((choice, i) => (i === active ? toggle(choice) : choice)));
+        }
+        else if (key.name === 'a') {
+            const selectAll = Boolean(items.find((choice) => isSelectable(choice) && !choice.checked));
+            setItems(items.map(check(selectAll)));
+        }
+        else if (key.name === 'i') {
+            setItems(items.map(toggle));
+        }
+        else if (isNumberKey(key)) {
+            const position = Number(key.name) - 1;
+            const item = items[position];
+            if (item != null && isSelectable(item)) {
+                setActive(position);
+                setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+            }
+        }
+        else if (isMoveItemUpKey(key) || isMoveItemDownKey(key)) {
+            setShowHelpTip(false);
+            if (items.length < 2) {
+                return;
+            }
+            const offset = isMoveItemUpKey(key) ? -1 : 1;
+            let moveActiveTo = active + offset;
+            if (!config.sortingLoop &&
+                (moveActiveTo < 0 || moveActiveTo > items.length - 1)) {
+                return;
+            }
+            let newItems;
+            if (moveActiveTo === -1) {
+                newItems = [...items.slice(1), items[0]];
+                moveActiveTo = items.length - 1;
+            }
+            else if (moveActiveTo === items.length) {
+                newItems = [items.at(-1), ...items.slice(0, -1)];
+                moveActiveTo = 0;
+            }
+            else {
+                newItems = [...items];
+                newItems[moveActiveTo] = items[active];
+                newItems[active] = items[moveActiveTo];
+            }
+            setItems(newItems);
+            setActive(moveActiveTo);
+        }
+    });
+    const message = theme.style.message(config.message, status);
+    const page = usePagination({
+        items,
+        active,
+        renderItem({ item, isActive }) {
+            const line = item.name || item.value;
+            if (item.disabled) {
+                const disabledLabel = typeof item.disabled === 'string' ? item.disabled : '(disabled)';
+                return theme.style.disabledChoice(`${line} ${disabledLabel}`);
+            }
+            const checkbox = item.checked
+                ? theme.icon.checked
+                : theme.icon.unchecked;
+            const color = isActive
+                ? theme.style.highlight
+                : (x) => x;
+            const cursor = isActive ? theme.icon.cursor : ' ';
+            return color(`${cursor}${checkbox} ${line}`);
+        },
+        pageSize,
+        loop: false,
+    });
+    if (status === 'done') {
+        const selection = items.filter(isChecked);
+        const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+        return `${prefix} ${message} ${answer}`;
+    }
+    let helpTipTop = '';
+    let helpTipBottom = '';
+    if (theme.helpMode === 'always' ||
+        (theme.helpMode === 'auto' &&
+            showHelpTip &&
+            (instructions === undefined || instructions))) {
+        if (typeof instructions === 'string') {
+            helpTipTop = instructions;
+        }
+        else {
+            const keys = [
+                `${theme.style.key('space')} to select`,
+                `${theme.style.key('a')} to toggle all`,
+                `${theme.style.key('i')} to invert selection`,
+                `${theme.style.key('shift+up')} to move item up`,
+                `${theme.style.key('shift+down')} to move item down`,
+                `and ${theme.style.key('enter')} to proceed`,
+            ];
+            helpTipTop = ` (Press ${keys.join(', ')})`;
+        }
+        if (items.length > pageSize &&
+            (theme.helpMode === 'always' ||
+                (theme.helpMode === 'auto' && firstRender.current))) {
+            helpTipBottom = `\n${theme.style.help('(Use arrow keys to reveal more choices)')}`;
+            firstRender.current = false;
+        }
+    }
+    let error = '';
+    if (errorMsg) {
+        error = `\n${theme.style.error(errorMsg)}`;
+    }
+    return `${prefix} ${message}${helpTipTop}\n${page}${helpTipBottom}${error}${ansiEscapes.cursorHide}`;
+});
+function isSelectable(item) {
+    return !item.disabled;
+}
+function isChecked(item) {
+    return isSelectable(item) && Boolean(item.checked);
+}
+function toggle(item) {
+    return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+    return function (item) {
+        return isSelectable(item) ? { ...item, checked } : item;
+    };
+}
+function isActivatePreviousItemKey(key) {
+    return isUpKey(key) && !key.shift;
+}
+function isActivateNextItemKey(key) {
+    return isDownKey(key) && !key.shift;
+}
+function isMoveItemUpKey(key) {
+    return key.shift && isUpKey(key);
+}
+function isMoveItemDownKey(key) {
+    return key.shift && isDownKey(key);
+}

package/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import main from './dist/index.js';
+
+const program = new Command();
+
+program
+  .name('job-queue')
+  .description(
+    'A CLI app to keep track of jobs/tasks built around a couple of JSON files.',
+  )
+  .version('0.0.0')
+  .option(
+    '-c, --config <path>',
+    'path to directory containing config.json (uses new system app dir by default)',
+  )
+  .option(
+    '-j, --jobqueue <path>',
+    'path to jobqueue.json (uses config by default)',
+  )
+  .option(
+    '-p, --projectpool <path>',
+    'path to projectpool.json (uses config by default)',
+  )
+  .option(
+    '-e, --editor <editor>',
+    'name of editor to use (uses config by default or git editor, if installed)',
+  )
+  .action(async (options) => {
+    const configDir = options.config;
+    delete options.config;
+    [('jobqueue', 'projectpool', 'editor')].forEach((key) => {
+      if (!options[key] || options[key].length === 0) delete options[key];
+    });
+
+    await main(configDir, { ...options })
+      .then(() => {
+        console.log(chalk.cyanBright('🖖 Live long and prosper...'));
+        process.exit();
+      })
+      .catch((error) => {
+        console.log(chalk.red('An error occured:'));
+        console.group();
+        console.log(error.message || error);
+        console.groupEnd();
+        process.exit(1);
+      });
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@uss-stargazer/job-queue",
+  "version": "0.0.1",
+  "description": "A CLI app to keep track of jobs/tasks built around a couple of JSON files.",
+  "author": "uss-stargazer",
+  "license": "Apache-2.0",
+  "repository": {  
+    "type": "git",
+    "url": "https://github.com/uss-stargazer/jobqueue.git"
+  },
+  "type": "module",
+  "bin": {
+    "job-queue": "./index.js",
+    "jobq": "./index.js"
+  },
+  "files": ["index.js", "dist/", "!TODO"],
+  "scripts": {
+    "start": "node ./index.js",
+    "clean": "rimraf coverage dist tmp",
+    "prebuild": "npm run lint",
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -w -p tsconfig.json",
+    "build:release": "npm run clean && tsc -p tsconfig.release.json",
+    "lint": "eslint .",
+    "prettier": "prettier \"{src,__{tests}__}/**/*.{ts,mts}\" --config .prettierrc --write",
+    "prettier:check": "prettier \"{src,__{tests}__}/**/*.{ts,mts}\" --config .prettierrc --check"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "@inquirer/search": "^4.1.0",
+    "ansi-escapes": "^7.2.0",
+    "chalk": "^5.6.2",
+    "clear": "^0.1.0",
+    "commander": "^14.0.2",
+    "edit-like-git": "^1.0.2",
+    "env-paths": "^4.0.0",
+    "figlet": "^1.9.4",
+    "inquirer": "^13.2.0",
+    "tmp-promise": "^3.0.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/eslint__js": "^8.42.3",
+    "@types/node": "^25.0.6",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.0.0",
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "ts-api-utils": "^2.4.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.52.0"
+  }
+}