@1zero/agentcron 0.1.0

package/dist/adapters/claude.d.ts

@@ -0,0 +1,11 @@
+import type { Skill } from '../core/skill-parser.js';
+import type { AgentAdapter, InstalledAutomation, WriteOptions } from './types.js';
+export declare class ClaudeAdapter implements AgentAdapter {
+    readonly agentId: "claude";
+    readonly agentName = "Claude Code";
+    private get basePath();
+    write(skill: Skill, _options: WriteOptions): Promise<string>;
+    read(name: string): Promise<Skill>;
+    list(): Promise<InstalledAutomation[]>;
+    remove(name: string): Promise<void>;
+}

package/dist/adapters/claude.js

@@ -0,0 +1,76 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+import { parseSkillMd, serializeSkillMd } from '../core/skill-parser.js';
+export class ClaudeAdapter {
+    agentId = 'claude';
+    agentName = 'Claude Code';
+    get basePath() {
+        return path.join(homedir(), '.claude', 'scheduled-tasks');
+    }
+    async write(skill, _options) {
+        const taskDir = path.join(this.basePath, skill.meta.name);
+        mkdirSync(taskDir, { recursive: true });
+        const claudeMeta = {
+            name: skill.meta.name,
+            description: skill.meta.description
+        };
+        const content = serializeSkillMd(claudeMeta, skill.prompt);
+        writeFileSync(path.join(taskDir, 'SKILL.md'), content, 'utf-8');
+        for (const [filename, fileContent] of skill.auxiliaryFiles) {
+            writeFileSync(path.join(taskDir, filename), fileContent, 'utf-8');
+        }
+        return taskDir;
+    }
+    async read(name) {
+        const taskDir = path.join(this.basePath, name);
+        const skillMdPath = path.join(taskDir, 'SKILL.md');
+        if (!existsSync(skillMdPath)) {
+            throw new Error('Claude scheduled task "' + name + '" not found');
+        }
+        const raw = readFileSync(skillMdPath, 'utf-8');
+        const { meta, prompt } = parseSkillMd(raw);
+        meta.source_agent = 'claude';
+        const auxiliaryFiles = new Map();
+        for (const file of readdirSync(taskDir)) {
+            if (file !== 'SKILL.md') {
+                const filePath = path.join(taskDir, file);
+                try {
+                    auxiliaryFiles.set(file, readFileSync(filePath, 'utf-8'));
+                }
+                catch {
+                    // 바이너리는 건너뜀
+                }
+            }
+        }
+        return { meta, prompt, auxiliaryFiles };
+    }
+    async list() {
+        if (!existsSync(this.basePath))
+            return [];
+        const entries = readdirSync(this.basePath, { withFileTypes: true });
+        const results = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(this.basePath, entry.name, 'SKILL.md');
+                if (existsSync(skillPath)) {
+                    const raw = readFileSync(skillPath, 'utf-8');
+                    const { meta } = parseSkillMd(raw);
+                    results.push({
+                        name: meta.name || entry.name,
+                        agent: 'claude',
+                        schedule: typeof meta.schedule === 'string' ? meta.schedule : undefined,
+                        path: path.join(this.basePath, entry.name)
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    async remove(name) {
+        const taskDir = path.join(this.basePath, name);
+        if (existsSync(taskDir)) {
+            rmSync(taskDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/adapters/codex.d.ts

@@ -0,0 +1,11 @@
+import type { Skill } from '../core/skill-parser.js';
+import type { AgentAdapter, InstalledAutomation, WriteOptions } from './types.js';
+export declare class CodexAdapter implements AgentAdapter {
+    readonly agentId: "codex";
+    readonly agentName = "Codex App";
+    private get basePath();
+    write(skill: Skill, options: WriteOptions): Promise<string>;
+    read(id: string): Promise<Skill>;
+    list(): Promise<InstalledAutomation[]>;
+    remove(id: string): Promise<void>;
+}

package/dist/adapters/codex.js

@@ -0,0 +1,113 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+import TOML from '@iarna/toml';
+import { isCron } from '../core/schedule.js';
+import { cronToRRule } from '../core/schedule.js';
+export class CodexAdapter {
+    agentId = 'codex';
+    agentName = 'Codex App';
+    get basePath() {
+        return path.join(homedir(), '.codex', 'automations');
+    }
+    async write(skill, options) {
+        const automationDir = path.join(this.basePath, skill.meta.name);
+        mkdirSync(automationDir, { recursive: true });
+        let rrule = '';
+        if (skill.meta.schedule) {
+            const schedule = String(skill.meta.schedule);
+            rrule = isCron(schedule) ? cronToRRule(schedule) : schedule;
+            if (!rrule.startsWith('RRULE:'))
+                rrule = 'RRULE:' + rrule;
+        }
+        const now = Date.now();
+        const toml = {
+            version: 1,
+            id: skill.meta.name,
+            kind: 'cron',
+            name: skill.meta.description || skill.meta.name,
+            prompt: skill.prompt,
+            status: options.status || 'ACTIVE',
+            rrule,
+            model: typeof skill.meta.model === 'string' ? skill.meta.model : 'gpt-5.4',
+            reasoning_effort: typeof skill.meta.reasoning_effort === 'string' ? skill.meta.reasoning_effort : 'high',
+            execution_environment: 'local',
+            cwds: options.cwds || [process.cwd()],
+            created_at: now,
+            updated_at: now
+        };
+        writeFileSync(path.join(automationDir, 'automation.toml'), TOML.stringify(toml), 'utf-8');
+        for (const [filename, fileContent] of skill.auxiliaryFiles) {
+            writeFileSync(path.join(automationDir, filename), fileContent, 'utf-8');
+        }
+        return automationDir;
+    }
+    async read(id) {
+        const automationDir = path.join(this.basePath, id);
+        const tomlPath = path.join(automationDir, 'automation.toml');
+        if (!existsSync(tomlPath)) {
+            throw new Error('Codex automation "' + id + '" not found');
+        }
+        const raw = readFileSync(tomlPath, 'utf-8');
+        const toml = TOML.parse(raw);
+        const auxiliaryFiles = new Map();
+        const skipFiles = new Set(['automation.toml', 'memory.md', 'result.md', 'result.json', '.DS_Store']);
+        for (const file of readdirSync(automationDir)) {
+            if (!skipFiles.has(file) && !file.startsWith('result-') && !file.endsWith('.json')) {
+                const filePath = path.join(automationDir, file);
+                try {
+                    auxiliaryFiles.set(file, readFileSync(filePath, 'utf-8'));
+                }
+                catch {
+                    // 바이너리는 건너뜀
+                }
+            }
+        }
+        return {
+            meta: {
+                name: toml.id,
+                description: toml.name,
+                schedule: toml.rrule,
+                model: toml.model,
+                reasoning_effort: toml.reasoning_effort,
+                source_agent: 'codex'
+            },
+            prompt: toml.prompt,
+            auxiliaryFiles
+        };
+    }
+    async list() {
+        if (!existsSync(this.basePath))
+            return [];
+        const entries = readdirSync(this.basePath, { withFileTypes: true });
+        const results = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const tomlPath = path.join(this.basePath, entry.name, 'automation.toml');
+                if (existsSync(tomlPath)) {
+                    try {
+                        const raw = readFileSync(tomlPath, 'utf-8');
+                        const toml = TOML.parse(raw);
+                        results.push({
+                            name: toml.id || entry.name,
+                            agent: 'codex',
+                            schedule: toml.rrule,
+                            status: toml.status,
+                            path: path.join(this.basePath, entry.name)
+                        });
+                    }
+                    catch {
+                        // 손상된 파일은 건너뜀
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    async remove(id) {
+        const automationDir = path.join(this.basePath, id);
+        if (existsSync(automationDir)) {
+            rmSync(automationDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,20 @@
+import type { Skill } from '../core/skill-parser.js';
+export interface InstalledAutomation {
+    name: string;
+    agent: 'claude' | 'codex';
+    schedule?: string;
+    status?: string;
+    path: string;
+}
+export interface AgentAdapter {
+    readonly agentId: 'claude' | 'codex';
+    readonly agentName: string;
+    write(skill: Skill, options: WriteOptions): Promise<string>;
+    read(id: string): Promise<Skill>;
+    list(): Promise<InstalledAutomation[]>;
+    remove(id: string): Promise<void>;
+}
+export interface WriteOptions {
+    cwds?: string[];
+    status?: 'ACTIVE' | 'PAUSED';
+}

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/add.d.ts

@@ -0,0 +1,4 @@
+export declare function addCommand(repoSlug: string, options: {
+    target?: string;
+    cwd?: string;
+}): Promise<void>;

package/dist/commands/add.js

@@ -0,0 +1,101 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import ora from 'ora';
+import { ClaudeAdapter } from '../adapters/claude.js';
+import { CodexAdapter } from '../adapters/codex.js';
+import { detectAgents } from '../core/detector.js';
+import { fetchFromGitHub } from '../core/github.js';
+import { parseSkillMd } from '../core/skill-parser.js';
+import { addToLock, getLockEntry } from '../lock/lockfile.js';
+import { header, info, success, warn } from '../utils/display.js';
+import { confirm, inputCwd, selectAgents } from '../utils/prompt.js';
+export async function addCommand(repoSlug, options) {
+    const spinner = ora('Fetching ' + repoSlug + '...').start();
+    let fetchResult;
+    try {
+        fetchResult = await fetchFromGitHub(repoSlug);
+        spinner.stop();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        spinner.fail(message);
+        process.exit(1);
+    }
+    if (!fetchResult)
+        return;
+    const raw = readFileSync(fetchResult.skillMdPath, 'utf-8');
+    const { meta, prompt } = parseSkillMd(raw);
+    const auxiliaryFiles = new Map();
+    for (const file of fetchResult.files) {
+        const basename = path.basename(file);
+        if (basename !== 'SKILL.md' && basename !== 'README.md' && basename !== 'LICENSE') {
+            const fullPath = path.join(fetchResult.directory, basename);
+            try {
+                auxiliaryFiles.set(basename, readFileSync(fullPath, 'utf-8'));
+            }
+            catch {
+                // 텍스트 파일만 포함
+            }
+        }
+    }
+    const skill = { meta, prompt, auxiliaryFiles };
+    header(meta.name);
+    info(meta.description || '');
+    if (meta.schedule)
+        info('Schedule: ' + meta.schedule);
+    console.log();
+    const existing = getLockEntry(meta.name);
+    if (existing) {
+        warn(meta.name + ' is already installed');
+        const shouldUpdate = await confirm('Update to latest?');
+        if (!shouldUpdate)
+            return;
+    }
+    const agents = detectAgents();
+    info('Detected agents:');
+    for (const agent of agents) {
+        const version = agent.version ? ' v' + agent.version : '';
+        info('  ' + (agent.installed ? '✓' : '✗') + ' ' + agent.name + version);
+    }
+    console.log();
+    let selectedAgents;
+    if (options.target) {
+        const targetIds = options.target.split(',');
+        selectedAgents = agents.filter((agent) => targetIds.includes(agent.id) && agent.installed);
+    }
+    else {
+        selectedAgents = await selectAgents(agents);
+    }
+    if (selectedAgents.length === 0) {
+        warn('No agents selected');
+        return;
+    }
+    const cwd = options.cwd || (await inputCwd());
+    const adapters = selectedAgents.map((agent) => {
+        if (agent.id === 'claude')
+            return new ClaudeAdapter();
+        return new CodexAdapter();
+    });
+    console.log();
+    info('Creating files...');
+    const targets = {};
+    for (const adapter of adapters) {
+        try {
+            const createdPath = await adapter.write(skill, { cwds: [cwd] });
+            success(adapter.agentName + '  ' + createdPath);
+            targets[adapter.agentId] = createdPath;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            warn(adapter.agentName + '  ' + message);
+        }
+    }
+    addToLock(meta.name, {
+        source: repoSlug,
+        installed_at: new Date().toISOString(),
+        targets
+    });
+    success('Lock file updated');
+    console.log();
+    info('Done! Installed ' + meta.name + ' → ' + selectedAgents.length + ' agent(s)');
+}

package/dist/commands/export-cmd.d.ts

@@ -0,0 +1,3 @@
+export declare function exportCommand(id: string, options: {
+    output?: string;
+}): Promise<void>;

package/dist/commands/export-cmd.js

@@ -0,0 +1,46 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+import { ClaudeAdapter } from '../adapters/claude.js';
+import { CodexAdapter } from '../adapters/codex.js';
+import { serializeSkillMd } from '../core/skill-parser.js';
+import { error, header, info, success } from '../utils/display.js';
+export async function exportCommand(id, options) {
+    const claudeAdapter = new ClaudeAdapter();
+    const codexAdapter = new CodexAdapter();
+    let skill;
+    let sourceAgent = '';
+    try {
+        skill = await codexAdapter.read(id);
+        sourceAgent = 'Codex App';
+    }
+    catch {
+        try {
+            skill = await claudeAdapter.read(id);
+            sourceAgent = 'Claude Code';
+        }
+        catch {
+            error('Automation "' + id + '" not found in any agent');
+            process.exit(1);
+        }
+    }
+    if (!skill)
+        return;
+    header('Exporting: ' + skill.meta.name);
+    info('Source: ' + sourceAgent);
+    info('Description: ' + skill.meta.description);
+    if (skill.meta.schedule)
+        info('Schedule: ' + skill.meta.schedule);
+    console.log();
+    const outDir = options.output || path.join(process.cwd(), skill.meta.name);
+    mkdirSync(outDir, { recursive: true });
+    const content = serializeSkillMd(skill.meta, skill.prompt);
+    writeFileSync(path.join(outDir, 'SKILL.md'), content, 'utf-8');
+    success('SKILL.md');
+    for (const [filename, fileContent] of skill.auxiliaryFiles) {
+        writeFileSync(path.join(outDir, filename), fileContent, 'utf-8');
+        success(filename);
+    }
+    console.log();
+    info('Exported to ' + outDir);
+    info('Push to GitHub and share: npx agentcron add <your-username>/' + skill.meta.name);
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { ClaudeAdapter } from '../adapters/claude.js';
+import { CodexAdapter } from '../adapters/codex.js';
+import { readLock } from '../lock/lockfile.js';
+import { header, info } from '../utils/display.js';
+export async function listCommand() {
+    const claudeAdapter = new ClaudeAdapter();
+    const codexAdapter = new CodexAdapter();
+    const [claudeList, codexList] = await Promise.all([claudeAdapter.list(), codexAdapter.list()]);
+    const all = [...claudeList, ...codexList];
+    if (all.length === 0) {
+        info('No automations found.');
+        info('Install one: npx agentcron add <user/repo>');
+        return;
+    }
+    const lock = readLock();
+    header('Installed Automations');
+    console.log('  ' +
+        chalk.dim('Name'.padEnd(30)) +
+        '  ' +
+        chalk.dim('Agent'.padEnd(12)) +
+        '  ' +
+        chalk.dim('Status'.padEnd(10)) +
+        '  ' +
+        chalk.dim('Source'));
+    console.log('  ' + '─'.repeat(80));
+    for (const item of all) {
+        const statusText = item.status === 'ACTIVE'
+            ? chalk.green('active')
+            : item.status === 'PAUSED'
+                ? chalk.yellow('paused')
+                : chalk.dim('unknown');
+        const source = String(lock.automations[item.name]?.source || chalk.dim('local'));
+        const agentText = item.agent === 'claude' ? chalk.blue('Claude') : chalk.cyan('Codex');
+        console.log('  ' +
+            item.name.padEnd(30) +
+            '  ' +
+            agentText +
+            ' '.repeat(Math.max(0, 12 - item.agent.length)) +
+            '  ' +
+            statusText +
+            ' '.repeat(10) +
+            '  ' +
+            source);
+    }
+    console.log('\n  ' + chalk.dim('Total: ' + all.length + ' automation(s)'));
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1 @@
+export declare function removeCommand(name: string): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,45 @@
+import { ClaudeAdapter } from '../adapters/claude.js';
+import { CodexAdapter } from '../adapters/codex.js';
+import { getLockEntry, removeFromLock } from '../lock/lockfile.js';
+import { confirm } from '../utils/prompt.js';
+import { error, info, success, warn } from '../utils/display.js';
+export async function removeCommand(name) {
+    const lockEntry = getLockEntry(name);
+    if (!lockEntry) {
+        warn('"' + name + '" not in lock file, searching agents...');
+    }
+    const ok = await confirm('Remove "' + name + '" from all agents?');
+    if (!ok)
+        return;
+    const claudeAdapter = new ClaudeAdapter();
+    const codexAdapter = new CodexAdapter();
+    let removed = 0;
+    if (lockEntry?.targets?.claude || !lockEntry) {
+        try {
+            await claudeAdapter.remove(name);
+            success('Removed from Claude Code');
+            removed++;
+        }
+        catch {
+            // 없으면 무시
+        }
+    }
+    if (lockEntry?.targets?.codex || !lockEntry) {
+        try {
+            await codexAdapter.remove(name);
+            success('Removed from Codex App');
+            removed++;
+        }
+        catch {
+            // 없으면 무시
+        }
+    }
+    removeFromLock(name);
+    if (removed > 0) {
+        success('Lock file updated');
+        info('Done! Removed "' + name + '" from ' + removed + ' agent(s)');
+    }
+    else {
+        error('"' + name + '" not found in any agent');
+    }
+}

package/dist/core/detector.d.ts

@@ -0,0 +1,8 @@
+export interface AgentInfo {
+    name: string;
+    id: 'claude' | 'codex';
+    installed: boolean;
+    version?: string;
+    configPath: string;
+}
+export declare function detectAgents(): AgentInfo[];

package/dist/core/detector.js

@@ -0,0 +1,32 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+export function detectAgents() {
+    const home = homedir();
+    const agents = [
+        {
+            name: 'Claude Code',
+            id: 'claude',
+            installed: existsSync(path.join(home, '.claude')),
+            configPath: path.join(home, '.claude'),
+            version: tryGetVersion('claude --version')
+        },
+        {
+            name: 'Codex CLI',
+            id: 'codex',
+            installed: existsSync(path.join(home, '.codex')),
+            configPath: path.join(home, '.codex'),
+            version: tryGetVersion('codex --version')
+        }
+    ];
+    return agents;
+}
+function tryGetVersion(cmd) {
+    try {
+        return execSync(cmd, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n')[0];
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/github.d.ts

@@ -0,0 +1,6 @@
+export interface FetchResult {
+    skillMdPath: string;
+    directory: string;
+    files: string[];
+}
+export declare function fetchFromGitHub(repoSlug: string): Promise<FetchResult>;

package/dist/core/github.js

@@ -0,0 +1,48 @@
+import { createWriteStream, mkdirSync, readdirSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import * as tar from 'tar';
+export async function fetchFromGitHub(repoSlug) {
+    const [repo, branch = 'main'] = repoSlug.split('#');
+    const tarballUrl = 'https://github.com/' + repo + '/archive/refs/heads/' + branch + '.tar.gz';
+    const tmpDir = path.join(os.tmpdir(), 'agentcron-' + Date.now());
+    mkdirSync(tmpDir, { recursive: true });
+    const response = await fetch(tarballUrl);
+    if (!response.ok) {
+        throw new Error('Failed to fetch ' + repo + ': ' + response.status + ' ' + response.statusText);
+    }
+    if (!response.body) {
+        throw new Error('Failed to fetch ' + repo + ': empty response body');
+    }
+    const tarPath = path.join(tmpDir, 'repo.tar.gz');
+    const fileStream = createWriteStream(tarPath);
+    await pipeline(Readable.fromWeb(response.body), fileStream);
+    const extractDir = path.join(tmpDir, 'extracted');
+    mkdirSync(extractDir, { recursive: true });
+    await tar.x({ file: tarPath, cwd: extractDir, strip: 1 });
+    const files = listFilesRecursive(extractDir);
+    const skillMdPath = files.find((file) => path.basename(file) === 'SKILL.md');
+    if (!skillMdPath) {
+        throw new Error('No SKILL.md found in ' + repo);
+    }
+    return {
+        skillMdPath,
+        directory: path.dirname(skillMdPath),
+        files: files.map((file) => path.relative(extractDir, file))
+    };
+}
+function listFilesRecursive(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            results.push(...listFilesRecursive(fullPath));
+        }
+        else if (entry.isFile()) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}

package/dist/core/schedule.d.ts

@@ -0,0 +1,4 @@
+export declare function isCron(str: string): boolean;
+export declare function isRRule(str: string): boolean;
+export declare function cronToRRule(cron: string): string;
+export declare function rruleToCron(rruleStr: string): string;

package/dist/core/schedule.js

@@ -0,0 +1,81 @@
+function expandCronField(field) {
+    const results = [];
+    for (const part of field.split(',')) {
+        if (part.includes('-')) {
+            const [start, end] = part.split('-').map(Number);
+            for (let i = start; i <= end; i += 1)
+                results.push(i);
+        }
+        else if (part !== '*') {
+            results.push(Number(part));
+        }
+    }
+    return results;
+}
+export function isCron(str) {
+    const parts = str.trim().split(/\s+/);
+    return parts.length === 5;
+}
+export function isRRule(str) {
+    return str.startsWith('RRULE:') || str.startsWith('FREQ=');
+}
+export function cronToRRule(cron) {
+    const parts = cron.trim().split(/\s+/);
+    const [minute, hour, dom, _month, dow] = parts;
+    const dayMap = {
+        '0': 'SU',
+        '1': 'MO',
+        '2': 'TU',
+        '3': 'WE',
+        '4': 'TH',
+        '5': 'FR',
+        '6': 'SA',
+        '7': 'SU'
+    };
+    const rruleParts = [];
+    if (dow !== '*' && dom === '*') {
+        rruleParts.push('FREQ=WEEKLY');
+        const days = expandCronField(dow)
+            .map((day) => dayMap[String(day)] || '')
+            .filter(Boolean);
+        if (days.length > 0)
+            rruleParts.push('BYDAY=' + days.join(','));
+    }
+    else if (dom !== '*') {
+        rruleParts.push('FREQ=MONTHLY');
+        rruleParts.push('BYMONTHDAY=' + dom);
+    }
+    else {
+        rruleParts.push('FREQ=DAILY');
+    }
+    if (hour !== '*')
+        rruleParts.push('BYHOUR=' + hour);
+    if (minute !== '*')
+        rruleParts.push('BYMINUTE=' + minute);
+    return 'RRULE:' + rruleParts.join(';');
+}
+export function rruleToCron(rruleStr) {
+    const str = rruleStr.replace('RRULE:', '');
+    const params = Object.fromEntries(str.split(';').map((part) => {
+        const [key, value = ''] = part.split('=');
+        return [key, value];
+    }));
+    const minute = params.BYMINUTE || '0';
+    const hour = params.BYHOUR || '*';
+    const dom = params.BYMONTHDAY || '*';
+    const month = '*';
+    const rruleDayMap = {
+        MO: '1',
+        TU: '2',
+        WE: '3',
+        TH: '4',
+        FR: '5',
+        SA: '6',
+        SU: '0'
+    };
+    let dow = '*';
+    if (params.BYDAY) {
+        dow = params.BYDAY.split(',').map((day) => rruleDayMap[day] || day).join(',');
+    }
+    return minute + ' ' + hour + ' ' + dom + ' ' + month + ' ' + dow;
+}

package/dist/core/skill-parser.d.ts

@@ -0,0 +1,19 @@
+export interface SkillMeta {
+    name: string;
+    description: string;
+    schedule?: string;
+    model?: string;
+    reasoning_effort?: string;
+    source_agent?: 'claude' | 'codex';
+    [key: string]: unknown;
+}
+export interface Skill {
+    meta: SkillMeta;
+    prompt: string;
+    auxiliaryFiles: Map<string, string>;
+}
+export declare function parseSkillMd(content: string): {
+    meta: SkillMeta;
+    prompt: string;
+};
+export declare function serializeSkillMd(meta: SkillMeta, prompt: string): string;

package/dist/core/skill-parser.js

@@ -0,0 +1,8 @@
+import matter from 'gray-matter';
+export function parseSkillMd(content) {
+    const { data, content: body } = matter(content);
+    return { meta: data, prompt: body.trim() };
+}
+export function serializeSkillMd(meta, prompt) {
+    return matter.stringify(prompt, meta);
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { addCommand } from './commands/add.js';
+import { exportCommand } from './commands/export-cmd.js';
+import { listCommand } from './commands/list.js';
+import { removeCommand } from './commands/remove.js';
+const program = new Command();
+program
+    .name('agentcron')
+    .description('Share AI agent automations across Claude Code and Codex App')
+    .version('0.1.0');
+program
+    .command('add <repo>')
+    .description('Install an automation from a GitHub repo (user/repo)')
+    .option('--target <agents>', 'Comma-separated agent targets (claude,codex)')
+    .option('--cwd <path>', 'Working directory for the automation')
+    .action(addCommand);
+program
+    .command('export <id>')
+    .description('Export an existing automation to SKILL.md format')
+    .option('-o, --output <dir>', 'Output directory')
+    .action(exportCommand);
+program
+    .command('list')
+    .description('List all installed automations')
+    .action(listCommand);
+program
+    .command('remove <name>')
+    .description('Remove an installed automation')
+    .action(removeCommand);
+program.parse();

package/dist/lock/lockfile.d.ts

@@ -0,0 +1,16 @@
+interface LockEntry {
+    source: string;
+    installed_at: string;
+    targets: Record<string, string>;
+    version?: string;
+}
+interface LockData {
+    version: number;
+    automations: Record<string, LockEntry>;
+}
+export declare function readLock(): LockData;
+export declare function writeLock(data: LockData): void;
+export declare function addToLock(name: string, entry: LockEntry): void;
+export declare function removeFromLock(name: string): void;
+export declare function getLockEntry(name: string): LockEntry | undefined;
+export {};

package/dist/lock/lockfile.js

@@ -0,0 +1,28 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+const LOCK_DIR = path.join(homedir(), '.agentcron');
+const LOCK_FILE = path.join(LOCK_DIR, 'lock.json');
+export function readLock() {
+    if (!existsSync(LOCK_FILE)) {
+        return { version: 1, automations: {} };
+    }
+    return JSON.parse(readFileSync(LOCK_FILE, 'utf-8'));
+}
+export function writeLock(data) {
+    mkdirSync(LOCK_DIR, { recursive: true });
+    writeFileSync(LOCK_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+export function addToLock(name, entry) {
+    const lock = readLock();
+    lock.automations[name] = entry;
+    writeLock(lock);
+}
+export function removeFromLock(name) {
+    const lock = readLock();
+    delete lock.automations[name];
+    writeLock(lock);
+}
+export function getLockEntry(name) {
+    return readLock().automations[name];
+}

package/dist/utils/display.d.ts

@@ -0,0 +1,6 @@
+export declare function header(text: string): void;
+export declare function success(text: string): void;
+export declare function warn(text: string): void;
+export declare function error(text: string): void;
+export declare function info(text: string): void;
+export declare function table(rows: [string, string][]): void;

package/dist/utils/display.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+export function header(text) {
+    console.log('\n  ' + chalk.bold(text) + '\n');
+}
+export function success(text) {
+    console.log('  ' + chalk.green('✓') + ' ' + text);
+}
+export function warn(text) {
+    console.log('  ' + chalk.yellow('⚠') + ' ' + text);
+}
+export function error(text) {
+    console.log('  ' + chalk.red('✗') + ' ' + text);
+}
+export function info(text) {
+    console.log('  ' + text);
+}
+export function table(rows) {
+    const maxKey = Math.max(...rows.map(([key]) => key.length));
+    for (const [key, value] of rows) {
+        console.log('  ' + chalk.dim(key.padEnd(maxKey)) + '  ' + value);
+    }
+}

package/dist/utils/prompt.d.ts

@@ -0,0 +1,4 @@
+import type { AgentInfo } from '../core/detector.js';
+export declare function selectAgents(agents: AgentInfo[]): Promise<AgentInfo[]>;
+export declare function inputCwd(): Promise<string>;
+export declare function confirm(message: string): Promise<boolean>;

package/dist/utils/prompt.js

@@ -0,0 +1,42 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+export async function selectAgents(agents) {
+    const { selected } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selected',
+            message: 'Select target agents',
+            choices: agents.map((agent) => ({
+                name: agent.name +
+                    (agent.version ? ' v' + agent.version : '') +
+                    (!agent.installed ? chalk.dim(' (not installed)') : ''),
+                value: agent.id,
+                checked: agent.installed,
+                disabled: !agent.installed ? 'not installed' : false
+            }))
+        }
+    ]);
+    return agents.filter((agent) => selected.includes(agent.id));
+}
+export async function inputCwd() {
+    const { cwd } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'cwd',
+            message: 'Working directory:',
+            default: process.cwd()
+        }
+    ]);
+    return cwd;
+}
+export async function confirm(message) {
+    const { ok } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'ok',
+            message,
+            default: true
+        }
+    ]);
+    return ok;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@1zero/agentcron",
+  "version": "0.1.0",
+  "description": "Share AI agent automations across Claude Code and Codex App",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "agentcron": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai",
+    "automation",
+    "claude",
+    "codex",
+    "cron",
+    "agent"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "cron-parser": "^5.5.0",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^13.4.1",
+    "ora": "^9.3.0",
+    "rrule": "^2.8.1",
+    "tar": "^7.5.13"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.6.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  }
+}