@crouton-kit/crouter 0.1.1 → 0.1.3

package/dist/core/artifact.js

@@ -0,0 +1,187 @@
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { CRTR_DIR_NAME } from '../types.js';
+import { ensureDir, pathExists, readText, walkFiles } from './fs-utils.js';
+import { usage, notFound, general } from './errors.js';
+import { out, hint, jsonOut, handleError } from './output.js';
+export function mangleCwd(cwd = process.cwd()) {
+    return cwd.replace(/\//g, '-');
+}
+export function artifactsRoot(kind, cwd) {
+    return join(homedir(), CRTR_DIR_NAME, mangleCwd(cwd), kind);
+}
+export function sanitizeName(raw) {
+    const trimmed = raw.trim().replace(/^\/+|\/+$/g, '');
+    if (trimmed === '')
+        throw usage('name must not be empty');
+    if (trimmed.split('/').some((seg) => seg === '..' || seg === '.')) {
+        throw usage(`name must not contain "." or ".." segments: ${raw}`);
+    }
+    if (trimmed.startsWith('/') || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+        throw usage(`name must not be absolute: ${raw}`);
+    }
+    return trimmed;
+}
+export function artifactPath(kind, name, cwd) {
+    return join(artifactsRoot(kind, cwd), `${sanitizeName(name)}.md`);
+}
+export function inTmux() {
+    return Boolean(process.env.TMUX);
+}
+export function openInTmuxPane(path) {
+    const result = spawnSync('termrender', ['--tmux', path], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        const code = result.error.code;
+        if (code === 'ENOENT') {
+            hint('termrender not found on $PATH — install it to auto-open in tmux');
+        }
+        else {
+            hint(`termrender failed: ${result.error.message}`);
+        }
+        return;
+    }
+    if (result.status !== 0) {
+        const stderrText = result.stderr.toString().trim();
+        hint(`termrender exited with ${result.status}${stderrText ? `: ${stderrText}` : ''}`);
+        return;
+    }
+    const paneId = result.stdout.toString().trim();
+    if (paneId)
+        hint(`opened in tmux pane ${paneId}`);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function listArtifactNames(kind) {
+    const root = artifactsRoot(kind);
+    if (!pathExists(root))
+        return [];
+    return walkFiles(root, (n) => n.endsWith('.md'))
+        .map((abs) => abs.substring(root.length + 1).replace(/\.md$/, ''))
+        .sort();
+}
+export function registerArtifactCommand(program, opts) {
+    const { command, kind, promptFn } = opts;
+    const cmd = program
+        .command(`${command} [content]`)
+        .description(`print the ${command} prompt, or save a ${command} with --name`)
+        .option('--name <name>', `save the ${command} under this name`)
+        .action(async (content, options) => {
+        try {
+            if (options.name === undefined) {
+                if (content !== undefined) {
+                    throw usage(`positional content requires --name (try \`crtr ${command} --name <name> ...\`)`);
+                }
+                out(promptFn(artifactsRoot(kind)));
+                return;
+            }
+            let body;
+            if (content !== undefined) {
+                body = content;
+            }
+            else if (!process.stdin.isTTY) {
+                body = await readStdin();
+            }
+            else {
+                throw usage(`no content provided. Pipe via stdin (heredoc) or pass as a positional arg:\n` +
+                    `  crtr ${command} --name <name> <<'EOF'\n  <content>\n  EOF`);
+            }
+            if (body.trim() === '') {
+                throw usage('content is empty');
+            }
+            const filePath = artifactPath(kind, options.name);
+            ensureDir(dirname(filePath));
+            writeFileSync(filePath, body.endsWith('\n') ? body : body + '\n', 'utf8');
+            out(filePath);
+            if (inTmux())
+                openInTmuxPane(filePath);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('list')
+        .description(`list ${kind} for the current directory`)
+        .option('--json', 'emit JSON')
+        .action(async (options) => {
+        try {
+            const names = listArtifactNames(kind);
+            if (options.json) {
+                jsonOut({
+                    [kind]: names.map((name) => ({ name, path: artifactPath(kind, name) })),
+                });
+                return;
+            }
+            for (const n of names)
+                out(n);
+        }
+        catch (e) {
+            handleError(e, { json: options.json });
+        }
+    });
+    cmd
+        .command('show <name>')
+        .description(`print the body of a ${command}`)
+        .action(async (name) => {
+        try {
+            const filePath = artifactPath(kind, name);
+            if (!pathExists(filePath)) {
+                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
+            }
+            out(readText(filePath));
+            hint(`crtr: edit with \`crtr ${command} edit ${name}\` (${filePath})`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('path [name]')
+        .description(`print the absolute path of a ${command} or the ${kind} directory`)
+        .action(async (name) => {
+        try {
+            out(name === undefined ? artifactsRoot(kind) : artifactPath(kind, name));
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('edit <name>')
+        .description(`open the ${command} in $EDITOR`)
+        .action(async (name) => {
+        try {
+            const filePath = artifactPath(kind, name);
+            if (!pathExists(filePath)) {
+                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
+            }
+            const editor = process.env.EDITOR !== undefined && process.env.EDITOR !== ''
+                ? process.env.EDITOR
+                : 'vi';
+            await new Promise((resolve, reject) => {
+                const child = spawn(editor, [filePath], { stdio: 'inherit' });
+                child.on('error', (e) => reject(general(`failed to launch editor: ${e.message}`)));
+                child.on('close', (code) => {
+                    if (code !== 0 && code !== null) {
+                        reject(general(`editor exited with code ${code}`));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}

package/dist/core/auto-update.d.ts

@@ -0,0 +1 @@
+export declare function maybeAutoUpdate(argv: string[]): void;

package/dist/core/auto-update.js

@@ -0,0 +1,86 @@
+import { spawn } from 'node:child_process';
+import { readConfig, readState, updateState } from './config.js';
+import { nowIso } from './fs-utils.js';
+import { info } from './output.js';
+import { selfCheck, contentCheck } from '../commands/update.js';
+const HOUR_MS = 60 * 60 * 1000;
+const SKIP_SUBCOMMANDS = new Set([
+    'update',
+    'help',
+    '--help',
+    '-h',
+    '--version',
+    '-v',
+]);
+function shouldSkipForArgv(argv) {
+    const sub = argv[2];
+    if (sub === undefined)
+        return true;
+    return SKIP_SUBCOMMANDS.has(sub);
+}
+function withinInterval(lastIso, intervalHours) {
+    if (!lastIso)
+        return false;
+    const last = Date.parse(lastIso);
+    if (!Number.isFinite(last))
+        return false;
+    return Date.now() - last < intervalHours * HOUR_MS;
+}
+function spawnDetachedSelfUpdate() {
+    const child = spawn('npm', ['i', '-g', '@crouton-kit/crtr@latest'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+function spawnDetachedContentUpdate() {
+    const child = spawn('crtr', ['update', '--content'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+export function maybeAutoUpdate(argv) {
+    try {
+        if (process.env.CRTR_NO_AUTO_UPDATE === '1')
+            return;
+        if (shouldSkipForArgv(argv))
+            return;
+        const cfg = readConfig('user');
+        const { crtr, content, interval_hours } = cfg.auto_update;
+        if (crtr === false && content === false)
+            return;
+        const state = readState('user');
+        if (state.last_self_check === undefined) {
+            updateState('user', (s) => {
+                s.last_self_check = nowIso();
+            });
+            return;
+        }
+        if (withinInterval(state.last_self_check, interval_hours))
+            return;
+        updateState('user', (s) => {
+            s.last_self_check = nowIso();
+        });
+        if (crtr === 'notify') {
+            selfCheck();
+        }
+        else if (crtr === 'apply') {
+            info('applying self-update in background');
+            spawnDetachedSelfUpdate();
+        }
+        if (content === 'notify') {
+            contentCheck();
+        }
+        else if (content === 'apply') {
+            info('applying content updates in background');
+            spawnDetachedContentUpdate();
+        }
+    }
+    catch (e) {
+        if (process.env.CRTR_DEBUG === '1') {
+            const msg = e instanceof Error ? e.message : String(e);
+            process.stderr.write(`crtr: auto-update hook error: ${msg}\n`);
+        }
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+import type { Scope, ScopeConfig, ScopeState } from '../types.js';
+export declare function configPath(scope: Scope): string | null;
+export declare function statePath(scope: Scope): string | null;
+export declare function readConfig(scope: Scope): ScopeConfig;
+export declare function readState(scope: Scope): ScopeState;
+export declare function writeConfig(scope: Scope, config: ScopeConfig): void;
+export declare function writeState(scope: Scope, state: ScopeState): void;
+export declare function ensureScopeInitialized(scope: Scope, root: string): void;
+export declare function updateConfig(scope: Scope, mutate: (cfg: ScopeConfig) => void): ScopeConfig;
+export declare function updateState(scope: Scope, mutate: (s: ScopeState) => void): ScopeState;

package/dist/core/config.js

@@ -0,0 +1,96 @@
+import { join } from 'node:path';
+import { CONFIG_FILE, STATE_FILE, defaultScopeConfig, defaultScopeState } from '../types.js';
+import { readJsonIfExists, writeJson, ensureDir } from './fs-utils.js';
+import { scopeRoot, requireScopeRoot } from './scope.js';
+function configPathFor(root) {
+    return join(root, CONFIG_FILE);
+}
+function statePathFor(root) {
+    return join(root, STATE_FILE);
+}
+export function configPath(scope) {
+    const root = scopeRoot(scope);
+    return root ? configPathFor(root) : null;
+}
+export function statePath(scope) {
+    const root = scopeRoot(scope);
+    return root ? statePathFor(root) : null;
+}
+export function readConfig(scope) {
+    const root = scopeRoot(scope);
+    if (!root)
+        return defaultScopeConfig();
+    const existing = readJsonIfExists(configPathFor(root));
+    if (!existing)
+        return defaultScopeConfig();
+    return mergeConfig(existing);
+}
+export function readState(scope) {
+    const root = scopeRoot(scope);
+    if (!root)
+        return defaultScopeState();
+    const existing = readJsonIfExists(statePathFor(root));
+    if (!existing)
+        return defaultScopeState();
+    return {
+        marketplaces: existing.marketplaces ?? {},
+        plugins: existing.plugins ?? {},
+        last_self_check: existing.last_self_check,
+    };
+}
+export function writeConfig(scope, config) {
+    const root = requireScopeRoot(scope);
+    ensureDir(root);
+    writeJson(configPathFor(root), config);
+}
+export function writeState(scope, state) {
+    const root = requireScopeRoot(scope);
+    ensureDir(root);
+    writeJson(statePathFor(root), state);
+}
+export function ensureScopeInitialized(scope, root) {
+    ensureDir(root);
+    const cfgPath = configPathFor(root);
+    if (!readJsonIfExists(cfgPath)) {
+        writeJson(cfgPath, defaultScopeConfig());
+    }
+}
+function normalizeMode(value, fallback) {
+    if (value === true)
+        return 'notify';
+    if (value === false)
+        return false;
+    if (value === 'notify' || value === 'apply')
+        return value;
+    return fallback;
+}
+function mergeConfig(partial) {
+    const defaults = defaultScopeConfig();
+    const schema_version = partial.schema_version === undefined ? defaults.schema_version : partial.schema_version;
+    const marketplaces = partial.marketplaces === undefined ? {} : partial.marketplaces;
+    const plugins = partial.plugins === undefined ? {} : partial.plugins;
+    const skills = partial.skills === undefined ? {} : partial.skills;
+    const au = partial.auto_update;
+    const rawInterval = au && typeof au.interval_hours === 'number' ? au.interval_hours : undefined;
+    const interval_hours = rawInterval !== undefined && Number.isFinite(rawInterval) && rawInterval >= 0
+        ? rawInterval
+        : defaults.auto_update.interval_hours;
+    const auto_update = {
+        crtr: normalizeMode(au?.crtr, defaults.auto_update.crtr),
+        content: normalizeMode(au?.content, defaults.auto_update.content),
+        interval_hours,
+    };
+    return { schema_version, marketplaces, plugins, skills, auto_update };
+}
+export function updateConfig(scope, mutate) {
+    const cfg = readConfig(scope);
+    mutate(cfg);
+    writeConfig(scope, cfg);
+    return cfg;
+}
+export function updateState(scope, mutate) {
+    const s = readState(scope);
+    mutate(s);
+    writeState(scope, s);
+    return s;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCodeValue } from '../types.js';
+export declare class CrtrError extends Error {
+    code: string;
+    exitCode: ExitCodeValue;
+    details?: Record<string, unknown>;
+    constructor(code: string, message: string, exitCode?: ExitCodeValue, details?: Record<string, unknown>);
+}
+export declare function notFound(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function usage(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function ambiguous(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function network(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function general(message: string, details?: Record<string, unknown>): CrtrError;

package/dist/core/errors.js

@@ -0,0 +1,28 @@
+import { ExitCode } from '../types.js';
+export class CrtrError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(code, message, exitCode = ExitCode.GENERAL, details) {
+        super(message);
+        this.name = 'CrtrError';
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+}
+export function notFound(message, details) {
+    return new CrtrError('not_found', message, ExitCode.NOT_FOUND, details);
+}
+export function usage(message, details) {
+    return new CrtrError('usage', message, ExitCode.USAGE, details);
+}
+export function ambiguous(message, details) {
+    return new CrtrError('ambiguous', message, ExitCode.AMBIGUOUS, details);
+}
+export function network(message, details) {
+    return new CrtrError('network', message, ExitCode.NETWORK, details);
+}
+export function general(message, details) {
+    return new CrtrError('error', message, ExitCode.GENERAL, details);
+}

package/dist/core/frontmatter.d.ts

@@ -0,0 +1,8 @@
+import type { SkillFrontmatter } from '../types.js';
+export interface ParsedFrontmatter {
+    data: SkillFrontmatter | null;
+    body: string;
+    raw: string;
+}
+export declare function parseFrontmatter(source: string): ParsedFrontmatter;
+export declare function serializeFrontmatter(data: SkillFrontmatter): string;

package/dist/core/frontmatter.js

@@ -0,0 +1,156 @@
+const FRONTMATTER_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
+export function parseFrontmatter(source) {
+    const match = source.match(FRONTMATTER_RE);
+    if (!match) {
+        return { data: null, body: source, raw: '' };
+    }
+    const raw = match[1];
+    const body = source.slice(match[0].length);
+    return { data: parseSimpleYaml(raw), body, raw };
+}
+function parseSimpleYaml(yaml) {
+    const lines = yaml.split(/\r?\n/);
+    const out = {};
+    let i = 0;
+    while (i < lines.length) {
+        const raw = lines[i];
+        if (!raw.trim()) {
+            i++;
+            continue;
+        }
+        const idx = raw.indexOf(':');
+        if (idx === -1) {
+            i++;
+            continue;
+        }
+        const key = raw.slice(0, idx).trim();
+        const rest = raw.slice(idx + 1).trim();
+        // Block scalar: `key: |` or `key: >` with optional chomp indicator (-/+)
+        const blockMatch = rest.match(/^([|>])([-+]?)\s*$/);
+        if (blockMatch) {
+            const style = blockMatch[1];
+            const chomp = blockMatch[2];
+            const collected = [];
+            let blockIndent = null;
+            let j = i + 1;
+            while (j < lines.length) {
+                const r = lines[j];
+                if (r.trim() === '') {
+                    collected.push('');
+                    j++;
+                    continue;
+                }
+                const ind = r.match(/^(\s*)/)?.[1].length ?? 0;
+                if (blockIndent === null) {
+                    if (ind === 0)
+                        break;
+                    blockIndent = ind;
+                }
+                if (ind < blockIndent)
+                    break;
+                collected.push(r.slice(blockIndent));
+                j++;
+            }
+            while (collected.length > 0 && collected[collected.length - 1] === '')
+                collected.pop();
+            let value;
+            if (style === '|') {
+                value = collected.join('\n');
+            }
+            else {
+                const parts = [];
+                let para = [];
+                for (const ln of collected) {
+                    if (ln === '') {
+                        if (para.length > 0) {
+                            parts.push(para.join(' '));
+                            para = [];
+                        }
+                        parts.push('');
+                    }
+                    else {
+                        para.push(ln);
+                    }
+                }
+                if (para.length > 0)
+                    parts.push(para.join(' '));
+                const folded = [];
+                for (let k = 0; k < parts.length; k++) {
+                    if (parts[k] === '' && (k === 0 || parts[k - 1] === ''))
+                        continue;
+                    folded.push(parts[k]);
+                }
+                value = folded.join('\n').replace(/\n+$/, '');
+            }
+            if (chomp !== '+')
+                value = value.replace(/\n+$/, '');
+            out[key] = value;
+            i = j;
+            continue;
+        }
+        // Empty value: could be a list on subsequent lines
+        if (rest === '') {
+            const buf = [];
+            let j = i + 1;
+            while (j < lines.length) {
+                const r = lines[j];
+                if (r.trim() === '') {
+                    j++;
+                    continue;
+                }
+                if (/^\s*-\s+/.test(r)) {
+                    buf.push(stripQuotes(r.replace(/^\s*-\s+/, '').trim()));
+                    j++;
+                    continue;
+                }
+                break;
+            }
+            if (buf.length > 0)
+                out[key] = buf;
+            i = j;
+            continue;
+        }
+        if (rest.startsWith('[') && rest.endsWith(']')) {
+            out[key] = rest
+                .slice(1, -1)
+                .split(',')
+                .map((s) => stripQuotes(s.trim()))
+                .filter(Boolean);
+            i++;
+            continue;
+        }
+        out[key] = stripQuotes(rest);
+        i++;
+    }
+    const fm = {
+        name: typeof out.name === 'string' ? out.name : '',
+        description: typeof out.description === 'string' ? out.description : undefined,
+        keywords: Array.isArray(out.keywords) ? out.keywords : undefined,
+    };
+    return fm;
+}
+function stripQuotes(s) {
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+export function serializeFrontmatter(data) {
+    const lines = ['---'];
+    lines.push(`name: ${quoteIfNeeded(data.name)}`);
+    if (data.description !== undefined) {
+        lines.push(`description: ${quoteIfNeeded(data.description)}`);
+    }
+    if (data.keywords && data.keywords.length) {
+        const inline = `[${data.keywords.map(quoteIfNeeded).join(', ')}]`;
+        lines.push(`keywords: ${inline}`);
+    }
+    lines.push('---');
+    return lines.join('\n') + '\n';
+}
+function quoteIfNeeded(s) {
+    if (/[:#\-\[\]{},&*?|<>=!%@`]/.test(s) || /^\s/.test(s) || /\s$/.test(s)) {
+        return `"${s.replace(/"/g, '\\"')}"`;
+    }
+    return s;
+}

package/dist/core/fs-utils.d.ts

@@ -0,0 +1,18 @@
+export declare function ensureDir(dir: string): void;
+export declare function writeJson(path: string, data: unknown): void;
+export declare function readJson<T = unknown>(path: string): T;
+export declare function readJsonIfExists<T = unknown>(path: string): T | null;
+export declare function readTextIfExists(path: string): string | null;
+export declare function readText(path: string): string;
+export declare function isDir(path: string): boolean;
+export declare function isSymlink(path: string): boolean;
+export declare function pathExists(path: string): boolean;
+export declare function listDirs(path: string): string[];
+export declare function listEntries(path: string): string[];
+export declare function removePath(path: string): void;
+export declare function linkOrCopy(target: string, linkPath: string, opts?: {
+    noSymlink?: boolean;
+}): 'symlink' | 'copy';
+export declare function readSymlinkTarget(path: string): string | null;
+export declare function walkFiles(root: string, predicate?: (name: string) => boolean): string[];
+export declare function nowIso(): string;