centy-plugin-routines 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# centy-plugin-routines
+
+A Centy plugin that ships with a curated pool of **routines** — predefined repeatable processes, checklists, and workflows. Run the CLI to browse the catalog and add or update routines in your project.
+
+## What is a Routine?
+
+A routine is a recurring process — things like deployment checklists, sprint ceremonies, onboarding steps, or release workflows. This plugin provides a built-in catalog of ready-to-use routines so you don't have to write them from scratch.
+
+## Installation
+
+```bash
+# Install globally
+pnpm add -g centy-plugin-routines
+
+# Or run directly
+pnpm dlx centy-plugin-routines
+```
+
+Requires [centy-cli](https://github.com/centy-io/centy-cli) and [centy-daemon](https://github.com/centy-io/centy-daemon) to be installed and running.
+
+## Usage
+
+Run the CLI in any centy-initialized project:
+
+```bash
+centy-plugin-routines
+```
+
+The interactive prompt will:
+
+1. Display the catalog of available routines
+2. Show which routines are already installed in your project and whether updates are available
+3. Let you select a routine to **add** (if not yet installed) or **update** (if a newer version exists in the catalog)
+
+The selected routine is then created or updated in your project as a `routine` item type via the centy CLI.
+
+## How It Works
+
+Under the hood, the plugin:
+
+1. **Registers a custom item type** called `routine` via `centy item-type create` (first run only)
+2. **Lists existing routines** in the project via `centy list routines` to detect what's already installed
+3. **Compares** installed routines against the built-in catalog to determine available additions and updates
+4. **Creates** new routines via `centy create routine`
+5. **Updates** existing routines via `centy update routine <id>`
+
+### Routine Item Type
+
+The `routine` item type is created with the following configuration:
+
+| Property   | Value           |
+| ---------- | --------------- |
+| Name       | Routine         |
+| Identifier | slug            |
+| Features   | move, duplicate |
+
+## Commands
+
+| Command                     | Description                               |
+| --------------------------- | ----------------------------------------- |
+| `centy-plugin-routines`     | Browse catalog and add or update routines |
+| `centy list routines`       | List installed routines in your project   |
+| `centy get routine <id>`    | View a specific installed routine         |
+| `centy update routine <id>` | Update a routine directly via centy CLI   |
+| `centy delete routine <id>` | Remove a routine from your project        |
+
+Once routines are installed, you can also manage them directly with the `centy` CLI.
+
+## License
+
+MIT

package/dist/catalog.d.ts

@@ -0,0 +1,8 @@
+export interface CatalogRoutine {
+    slug: string;
+    title: string;
+    description: string;
+    version: number;
+    body: string;
+}
+export declare const catalog: CatalogRoutine[];

package/dist/catalog.js

@@ -0,0 +1,39 @@
+function withVersion(body, version) {
+    return `${body}\n\n<!-- centy-routine-version: ${version} -->`;
+}
+export const catalog = [
+    {
+        slug: 'replace-custom-with-libs',
+        title: 'Replace Custom Logic with Libraries',
+        description: 'Scan codebase for custom implementations that can be replaced by existing libraries',
+        version: 1,
+        body: withVersion(`# Replace Custom Logic with Libraries
+
+Scan the codebase for hand-rolled implementations that duplicate functionality already available in well-maintained open-source libraries. For each finding, create a centy issue describing the custom code, the suggested library replacement, and the benefit of switching.
+
+## What to Look For
+- Custom HTTP clients or request wrappers (replace with axios, ky, got, undici)
+- Hand-rolled date/time formatting or manipulation (replace with date-fns, dayjs, luxon)
+- Custom deep clone, merge, or diff utilities (replace with lodash, structuredClone, deepmerge)
+- DIY schema validation (replace with zod, yup, ajv, valibot)
+- Custom retry/backoff logic (replace with p-retry, async-retry)
+- Hand-written CSV/YAML/TOML/INI parsers (replace with papaparse, js-yaml, smol-toml)
+- Custom glob or file matching (replace with globby, picomatch, micromatch)
+- Custom slug/string utilities (replace with slugify, change-case)
+- Custom UUID/ID generation (replace with uuid, nanoid, cuid2)
+- Custom color/ANSI handling (replace with chalk, picocolors)
+- Custom argument parsing (replace with commander, yargs, citty)
+- Custom semver comparison (replace with semver)
+- Custom event emitter implementations (replace with eventemitter3, mitt)
+- Custom queue or rate-limiting logic (replace with p-queue, p-limit, bottleneck)
+- Custom caching layers (replace with lru-cache, keyv)
+
+## Process
+1. Walk through the source tree file by file
+2. Identify custom utility code that reimplements library functionality
+3. For each finding, create a centy issue with:
+   - Title: short description of what to replace
+   - Body: file path, lines of custom code, suggested library, and migration notes
+4. Mark this routine as completed when the full scan is done`, 1),
+    },
+];

package/dist/centy.d.ts

@@ -0,0 +1,11 @@
+export interface InstalledRoutine {
+    slug: string;
+    title: string;
+    body: string;
+    version: number;
+}
+export declare function parseVersion(body: string): number;
+export declare function ensureItemType(): void;
+export declare function listInstalledRoutines(): InstalledRoutine[];
+export declare function createRoutine(title: string, body: string): void;
+export declare function updateRoutine(slug: string, title: string, body: string): void;

package/dist/centy.js

@@ -0,0 +1,44 @@
+import { execFileSync } from 'node:child_process';
+function centy(...args) {
+    return execFileSync('centy', args, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+export function parseVersion(body) {
+    const match = body.match(/<!-- centy-routine-version: (\d+) -->/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+export function ensureItemType() {
+    try {
+        centy('list', 'routines', '--json');
+    }
+    catch {
+        centy('item-type', 'create', '--name', 'Routine', '--plural', 'routines', '--identifier', 'slug', '--statuses', 'active,completed', '--default-status', 'active');
+    }
+}
+export function listInstalledRoutines() {
+    try {
+        const output = centy('list', 'routines', '--json');
+        const items = JSON.parse(output);
+        return items.map(item => ({
+            slug: item.id,
+            title: item.title,
+            body: item.body,
+            version: parseVersion(item.body),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export function createRoutine(title, body) {
+    execFileSync('centy', ['create', 'routine', '--title', title, '--body', body], {
+        stdio: 'inherit',
+    });
+}
+export function updateRoutine(slug, title, body) {
+    execFileSync('centy', ['update', 'routine', slug, '--title', title, '--body', body], {
+        stdio: 'inherit',
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import prompts from 'prompts';
+import { catalog } from './catalog.js';
+import { ensureItemType, listInstalledRoutines, createRoutine, updateRoutine } from './centy.js';
+async function main() {
+    console.log('\ncenty-plugin-routines\n');
+    // Step 1: Ensure the routine item type is registered
+    try {
+        ensureItemType();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to ensure routine item type: ${msg}`);
+        console.error('Make sure centy-cli and centy-daemon are installed and running.');
+        process.exit(1);
+    }
+    // Step 2: List installed routines
+    const installed = listInstalledRoutines();
+    // Step 3: Build choices
+    const choices = catalog.map(routine => {
+        const existing = installed.find(r => r.slug === routine.slug);
+        if (!existing) {
+            return {
+                title: `[Add] ${routine.title}`,
+                description: routine.description,
+                value: { action: 'add', slug: routine.slug },
+            };
+        }
+        if (existing.version < routine.version) {
+            return {
+                title: `[Update] ${routine.title}  (v${existing.version} → v${routine.version})`,
+                description: routine.description,
+                value: { action: 'update', slug: routine.slug },
+            };
+        }
+        return {
+            title: `[Installed] ${routine.title}  (v${routine.version})`,
+            description: routine.description,
+            value: null,
+            disabled: true,
+        };
+    });
+    const actionable = choices.filter(c => !c.disabled);
+    if (actionable.length === 0) {
+        console.log('All routines are installed and up to date.');
+        return;
+    }
+    // Step 4: Prompt user to select routines
+    const response = await prompts({
+        type: 'multiselect',
+        name: 'selections',
+        message: 'Select routines to add or update (space to toggle, enter to confirm)',
+        choices,
+        instructions: false,
+    }, { onCancel: () => process.exit(0) });
+    const selections = response.selections;
+    if (!selections || selections.length === 0) {
+        console.log('No routines selected.');
+        return;
+    }
+    // Step 5: Execute the actions
+    for (const { action, slug } of selections) {
+        const routine = catalog.find(r => r.slug === slug);
+        try {
+            if (action === 'add') {
+                console.log(`\nAdding "${routine.title}"...`);
+                createRoutine(routine.title, routine.body);
+                console.log(`Routine "${routine.title}" added.`);
+            }
+            else {
+                console.log(`\nUpdating "${routine.title}"...`);
+                updateRoutine(slug, routine.title, routine.body);
+                console.log(`Routine "${routine.title}" updated.`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to ${action} routine "${routine.title}": ${msg}`);
+        }
+    }
+}
+main();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "centy-plugin-routines",
+  "version": "0.1.0",
+  "description": "A Centy plugin that ships with a curated pool of routines — predefined repeatable processes, checklists, and workflows.",
+  "type": "module",
+  "bin": {
+    "centy-plugin-routines": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "centy",
+    "plugin",
+    "routines",
+    "checklists",
+    "workflows"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/centy-io/centy-plugin-routines.git"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.7.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  }
+}