@shruubi/agentconfig 0.1.0 → 0.2.0

package/README.md

@@ -39,7 +39,8 @@ agentconfig sync
 - `--dry-run` Show actions without writing.
 - `--link` Force symlink mode.
 - `--copy` Force copy mode.
-- `--force` Overwrite unmanaged targets.
+- `--force` Overwrite unmanaged targets (alias for `--on-conflict overwrite`).
+- `--on-conflict <policy>` Choose how to handle existing unmanaged targets: `overwrite`, `backup`, `skip`, `cancel`.
 - `--agent <name>` Restrict to one agent.
 
 ## Config location

package/dist/cli.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+const errors_1 = require("./errors");
+const config_1 = require("./config");
+const templates_1 = require("./templates");
+const status_1 = require("./status");
+const sync_1 = require("./sync");
+const paths_1 = require("./paths");
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const result = {
+        command: null,
+        dryRun: false,
+        mode: null,
+        force: false,
+        help: false
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!result.command && !arg.startsWith("-")) {
+            result.command = arg;
+            continue;
+        }
+        if (arg === "--project") {
+            result.project = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            result.dryRun = true;
+            continue;
+        }
+        if (arg === "--link") {
+            result.mode = "link";
+            continue;
+        }
+        if (arg === "--copy") {
+            result.mode = "copy";
+            continue;
+        }
+        if (arg === "--force") {
+            result.force = true;
+            continue;
+        }
+        if (arg === "--on-conflict") {
+            const value = args[i + 1];
+            if (value === "overwrite" || value === "backup" || value === "skip" || value === "cancel") {
+                result.conflictPolicy = value;
+            }
+            i += 1;
+            continue;
+        }
+        if (arg === "--agent") {
+            result.agent = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            result.help = true;
+            continue;
+        }
+    }
+    return result;
+}
+function printHelp() {
+    const lines = [
+        "agentconfig <command> [options]",
+        "",
+        "Commands:",
+        "  init        Create agentconfig.yml in source root",
+        "  sync        Sync configs to agents",
+        "  status      Show drift status",
+        "  doctor      Validate config and paths",
+        "  list-agents List supported agents",
+        "",
+        "Options:",
+        "  --project <path>  Use project mode and root",
+        "  --dry-run         Show actions without writing",
+        "  --link            Force symlink mode",
+        "  --copy            Force copy mode",
+        "  --force           Overwrite unmanaged targets (alias for --on-conflict overwrite)",
+        "  --on-conflict <policy>  overwrite | backup | skip | cancel",
+        "  --agent <name>    Filter to one agent",
+        "  -h, --help        Show help"
+    ];
+    console.log(lines.join("\n"));
+}
+function ensureSourceRoot() {
+    const envRoot = process.env.AGENTCONFIG_HOME;
+    if (envRoot && envRoot.length > 0) {
+        return (0, paths_1.resolvePath)(envRoot, process.env);
+    }
+    return (0, paths_1.resolvePath)("~/.agentconfig", process.env);
+}
+async function run() {
+    const args = parseArgs(process.argv);
+    if (args.help || !args.command) {
+        printHelp();
+        return;
+    }
+    const sourceRoot = ensureSourceRoot();
+    switch (args.command) {
+        case "init": {
+            const configPath = (0, config_1.getConfigPath)(sourceRoot);
+            const exists = await promises_1.default
+                .access(configPath)
+                .then(() => true)
+                .catch(() => false);
+            if (exists) {
+                throw new errors_1.AgentConfigError(`Config already exists: ${configPath}`, errors_1.ExitCodes.Conflict);
+            }
+            await (0, config_1.writeConfig)(sourceRoot, (0, templates_1.createDefaultConfig)());
+            console.log(`Created ${configPath}`);
+            return;
+        }
+        case "sync": {
+            const config = await (0, config_1.readConfig)(sourceRoot);
+            const mode = args.project ? "project" : "global";
+            const projectRoot = args.project ? (0, paths_1.resolvePath)(args.project, process.env) : null;
+            const linkMode = args.mode ?? config.defaults.mode;
+            const result = await (0, sync_1.syncConfigs)({
+                config,
+                sourceRoot,
+                mode,
+                projectRoot,
+                linkMode,
+                dryRun: args.dryRun,
+                force: args.force,
+                conflictPolicy: args.conflictPolicy ?? (args.force ? "overwrite" : undefined),
+                agentFilter: args.agent
+            });
+            result.warnings.forEach((warning) => console.warn(warning));
+            console.log(`Planned: ${result.planned.length}`);
+            console.log(`Updated: ${result.updated.length}`);
+            console.log(`Skipped: ${result.skipped.length}`);
+            return;
+        }
+        case "status": {
+            const entries = await (0, status_1.getStatus)(sourceRoot);
+            if (entries.length === 0) {
+                console.log("No sync state found.");
+                return;
+            }
+            const drifted = entries.filter((entry) => entry.status !== "ok");
+            entries.forEach((entry) => {
+                const suffix = entry.reason ? ` (${entry.reason})` : "";
+                console.log(`${entry.status}: ${entry.path}${suffix}`);
+            });
+            if (drifted.length > 0) {
+                process.exitCode = errors_1.ExitCodes.Validation;
+            }
+            return;
+        }
+        case "doctor": {
+            const config = await (0, config_1.readConfig)(sourceRoot);
+            if (!config.defaults || !config.agents) {
+                throw new errors_1.AgentConfigError("Config missing defaults or agents", errors_1.ExitCodes.Validation);
+            }
+            console.log("Config OK");
+            return;
+        }
+        case "list-agents": {
+            const config = await (0, config_1.readConfig)(sourceRoot);
+            const agents = Object.entries(config.agents);
+            agents.forEach(([name, entry]) => {
+                console.log(`${name}: ${entry.displayName}`);
+            });
+            return;
+        }
+        default:
+            throw new errors_1.AgentConfigError(`Unknown command: ${String(args.command)}`, errors_1.ExitCodes.Usage);
+    }
+}
+run().catch((error) => {
+    if (error instanceof errors_1.AgentConfigError) {
+        console.error(error.message);
+        process.exit(error.code);
+    }
+    if (error instanceof Error) {
+        console.error(error.message);
+    }
+    else {
+        console.error("Unexpected error");
+    }
+    process.exit(errors_1.ExitCodes.Failure);
+});

package/dist/config.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG_FILE = void 0;
+exports.getConfigPath = getConfigPath;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const errors_1 = require("./errors");
+exports.DEFAULT_CONFIG_FILE = "agentconfig.yml";
+function getConfigPath(root) {
+    return path_1.default.join(root, exports.DEFAULT_CONFIG_FILE);
+}
+function isErrnoException(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function formatYamlError(error, configPath) {
+    if (error instanceof Error) {
+        const linePos = error.linePos?.[0];
+        const location = linePos ? ` (line ${linePos.line}, col ${linePos.col})` : "";
+        return new errors_1.AgentConfigError(`Invalid YAML in ${configPath}${location}: ${error.message}`, errors_1.ExitCodes.Validation);
+    }
+    return new errors_1.AgentConfigError(`Invalid YAML in ${configPath}`, errors_1.ExitCodes.Validation);
+}
+async function readConfig(root) {
+    const configPath = getConfigPath(root);
+    let raw;
+    try {
+        raw = await promises_1.default.readFile(configPath, "utf8");
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            throw new errors_1.AgentConfigError(`Missing config: ${configPath}`, errors_1.ExitCodes.Validation);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = yaml_1.default.parse(raw, { prettyErrors: true });
+    }
+    catch (error) {
+        throw formatYamlError(error, configPath);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new errors_1.AgentConfigError(`Invalid config format in ${configPath}`, errors_1.ExitCodes.Validation);
+    }
+    return parsed;
+}
+async function writeConfig(root, config) {
+    const configPath = getConfigPath(root);
+    const contents = yaml_1.default.stringify(config);
+    await promises_1.default.mkdir(root, { recursive: true });
+    await promises_1.default.writeFile(configPath, contents, "utf8");
+}

package/dist/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExitCodes = exports.AgentConfigError = void 0;
+class AgentConfigError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.AgentConfigError = AgentConfigError;
+exports.ExitCodes = {
+    Success: 0,
+    Failure: 1,
+    Usage: 2,
+    Validation: 3,
+    Conflict: 4,
+    Filesystem: 5
+};

package/dist/filesystem.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.fileExists = fileExists;
+exports.readLinkTarget = readLinkTarget;
+exports.hashFile = hashFile;
+exports.listEntries = listEntries;
+exports.copyFileOrDir = copyFileOrDir;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+function isErrnoException(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+async function ensureDir(target) {
+    await promises_1.default.mkdir(target, { recursive: true });
+}
+async function fileExists(target) {
+    try {
+        await promises_1.default.lstat(target);
+        return true;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readLinkTarget(target) {
+    try {
+        return await promises_1.default.readlink(target);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function hashFile(target) {
+    const hash = crypto_1.default.createHash("sha256");
+    await new Promise((resolve, reject) => {
+        const stream = (0, fs_1.createReadStream)(target);
+        stream.on("data", (chunk) => {
+            hash.update(chunk);
+        });
+        stream.on("error", (error) => {
+            reject(error);
+        });
+        stream.on("end", () => {
+            resolve();
+        });
+    });
+    return hash.digest("hex");
+}
+async function listEntries(target) {
+    return await promises_1.default.readdir(target);
+}
+async function copyFileOrDir(source, target) {
+    const stat = await promises_1.default.lstat(source);
+    if (stat.isDirectory()) {
+        await ensureDir(target);
+        const entries = await promises_1.default.readdir(source);
+        await Promise.all(entries.map(async (entry) => {
+            const src = path_1.default.join(source, entry);
+            const dest = path_1.default.join(target, entry);
+            await copyFileOrDir(src, dest);
+        }));
+        return;
+    }
+    await ensureDir(path_1.default.dirname(target));
+    await promises_1.default.copyFile(source, target);
+}

package/dist/paths.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandHome = expandHome;
+exports.expandEnv = expandEnv;
+exports.resolvePath = resolvePath;
+exports.resolveFromRoot = resolveFromRoot;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function expandHome(inputPath) {
+    if (inputPath === "~") {
+        return os_1.default.homedir();
+    }
+    if (inputPath.startsWith("~/")) {
+        return path_1.default.join(os_1.default.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+function expandEnv(inputPath, env) {
+    const resolved = inputPath.replace(/\$\{([A-Z0-9_]+)(:-([^}]*))?\}/gi, (_match, varName, _fallbackGroup, fallback) => {
+        const value = env[varName];
+        if (value && value.length > 0) {
+            return value;
+        }
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        return "";
+    });
+    return resolved;
+}
+function resolvePath(inputPath, env) {
+    const expanded = expandHome(expandEnv(inputPath, env));
+    if (path_1.default.isAbsolute(expanded)) {
+        return expanded;
+    }
+    return path_1.default.resolve(expanded);
+}
+function resolveFromRoot(root, relativePath) {
+    if (path_1.default.isAbsolute(relativePath)) {
+        return relativePath;
+    }
+    return path_1.default.join(root, relativePath);
+}

package/dist/state.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatePath = getStatePath;
+exports.readState = readState;
+exports.writeState = writeState;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+const STATE_FILE = ".sync-state.json";
+function getStatePath(root) {
+    return path_1.default.join(root, STATE_FILE);
+}
+function isErrnoException(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+async function readState(root) {
+    const statePath = getStatePath(root);
+    try {
+        const raw = await promises_1.default.readFile(statePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return null;
+        }
+        if (error instanceof SyntaxError) {
+            throw new errors_1.AgentConfigError(`Invalid JSON in ${statePath}: ${error.message}`, errors_1.ExitCodes.Validation);
+        }
+        throw error;
+    }
+}
+async function writeState(root, state) {
+    const statePath = getStatePath(root);
+    const contents = JSON.stringify(state, null, 2);
+    await promises_1.default.mkdir(root, { recursive: true });
+    await promises_1.default.writeFile(statePath, contents, "utf8");
+}

package/dist/status.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatus = getStatus;
+const promises_1 = __importDefault(require("fs/promises"));
+const state_1 = require("./state");
+const filesystem_1 = require("./filesystem");
+async function getStatus(stateRoot) {
+    const state = await (0, state_1.readState)(stateRoot);
+    if (!state) {
+        return [];
+    }
+    const results = [];
+    for (const record of Object.values(state.files)) {
+        const exists = await (0, filesystem_1.fileExists)(record.path);
+        if (!exists) {
+            results.push({ path: record.path, status: "missing", reason: "target missing" });
+            continue;
+        }
+        let stat = null;
+        if (record.mode === "link" || record.mode === "auto") {
+            stat = await promises_1.default.lstat(record.path);
+        }
+        const mode = record.mode === "auto" ? (stat?.isSymbolicLink() ? "link" : "copy") : record.mode;
+        if (mode === "link") {
+            if (!stat || !stat.isSymbolicLink()) {
+                results.push({ path: record.path, status: "drifted", reason: "link target changed" });
+                continue;
+            }
+            if (!record.linkTarget) {
+                results.push({ path: record.path, status: "drifted", reason: "link target changed" });
+                continue;
+            }
+            const linkTarget = await (0, filesystem_1.readLinkTarget)(record.path);
+            if (linkTarget !== record.linkTarget) {
+                results.push({ path: record.path, status: "drifted", reason: "link target changed" });
+                continue;
+            }
+            results.push({ path: record.path, status: "ok" });
+            continue;
+        }
+        if (!record.hash) {
+            results.push({ path: record.path, status: "drifted", reason: "content changed" });
+            continue;
+        }
+        const currentHash = await (0, filesystem_1.hashFile)(record.path);
+        if (currentHash !== record.hash) {
+            results.push({ path: record.path, status: "drifted", reason: "content changed" });
+            continue;
+        }
+        results.push({ path: record.path, status: "ok" });
+    }
+    return results;
+}

package/dist/sync.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncConfigs = syncConfigs;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_2 = require("readline/promises");
+const errors_1 = require("./errors");
+const filesystem_1 = require("./filesystem");
+const paths_1 = require("./paths");
+const state_1 = require("./state");
+async function syncConfigs(options) {
+    const { config, sourceRoot, mode, projectRoot, linkMode, dryRun, force, conflictPolicy, agentFilter } = options;
+    const resolvedMode = await resolveSyncMode(linkMode);
+    const resolvedMappings = resolveMappings(config, sourceRoot, mode, projectRoot, resolvedMode, agentFilter);
+    const warnings = [];
+    const stateRoot = sourceRoot;
+    const existingState = await (0, state_1.readState)(stateRoot);
+    const updatedMappings = [];
+    const skippedMappings = [];
+    let conflictState = { policy: conflictPolicy ?? null, canAsk: true };
+    for (const mapping of resolvedMappings) {
+        const targetExists = await (0, filesystem_1.fileExists)(mapping.target);
+        if (targetExists && !force && !isManaged(mapping.target, existingState)) {
+            const decision = await resolveConflictPolicy(mapping.target, conflictState);
+            conflictState = decision.state;
+            if (decision.action === "cancel") {
+                throw new errors_1.AgentConfigError("Sync cancelled", errors_1.ExitCodes.Conflict);
+            }
+            if (decision.action === "skip") {
+                warnings.push(`Skipping unmanaged target: ${mapping.target}`);
+                skippedMappings.push(mapping);
+                continue;
+            }
+            if (decision.action === "backup") {
+                if (!dryRun) {
+                    await backupTarget(mapping.target, sourceRoot);
+                }
+            }
+        }
+        if (dryRun) {
+            continue;
+        }
+        try {
+            await applyMapping(mapping, warnings);
+        }
+        catch (error) {
+            if (error instanceof errors_1.AgentConfigError) {
+                throw error;
+            }
+            throw new errors_1.AgentConfigError(`Failed to sync ${mapping.target}`, errors_1.ExitCodes.Filesystem);
+        }
+        updatedMappings.push(mapping);
+    }
+    if (!dryRun) {
+        const newState = await buildState(stateRoot, mode, projectRoot, updatedMappings, existingState);
+        await (0, state_1.writeState)(stateRoot, newState);
+    }
+    return {
+        planned: resolvedMappings,
+        updated: updatedMappings,
+        skipped: skippedMappings,
+        warnings
+    };
+}
+async function resolveConflictPolicy(target, state) {
+    if (state.policy) {
+        return { action: state.policy, state };
+    }
+    if (!state.canAsk || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return { action: "skip", state: { ...state, policy: "skip" } };
+    }
+    const choice = await promptConflictAction(target);
+    const resolved = choice.applyToAll ? choice.action : null;
+    return { action: choice.action, state: { policy: resolved, canAsk: !choice.applyToAll } };
+}
+async function promptConflictAction(target) {
+    const promptLines = [
+        `Config already exists at ${target}. Choose action:`,
+        "1) Overwrite",
+        "2) Backup then overwrite",
+        "3) Skip",
+        "4) Cancel"
+    ];
+    process.stdout.write(`${promptLines.join("\n")}\n> `);
+    const readline = (0, promises_2.createInterface)({ input: process.stdin, output: process.stdout });
+    const choice = await readline.question("");
+    const applyToAllAnswer = await readline.question("Apply to all conflicts? (y/N) ");
+    readline.close();
+    const applyToAll = /^(y|yes)$/i.test(applyToAllAnswer.trim());
+    const selection = Number.parseInt(choice.trim(), 10);
+    switch (selection) {
+        case 1:
+            return { action: "overwrite", applyToAll };
+        case 2:
+            return { action: "backup", applyToAll };
+        case 4:
+            return { action: "cancel", applyToAll };
+        case 3:
+        default:
+            return { action: "skip", applyToAll };
+    }
+}
+async function backupTarget(target, sourceRoot) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupRoot = path_1.default.join(sourceRoot, "backup", timestamp);
+    const relativeTarget = target.replace(/^[/\\]+/, "");
+    const destination = path_1.default.join(backupRoot, relativeTarget);
+    await (0, filesystem_1.ensureDir)(path_1.default.dirname(destination));
+    await (0, filesystem_1.copyFileOrDir)(target, destination);
+}
+function resolveMappings(config, sourceRoot, mode, projectRoot, linkMode, agentFilter) {
+    const mappings = [];
+    const agents = Object.entries(config.agents);
+    const profileFiles = getProfileFiles(config);
+    for (const [agent, agentConfig] of agents) {
+        if (agentFilter && agentFilter !== agent) {
+            continue;
+        }
+        const scopeConfig = mode === "global" ? agentConfig.global : agentConfig.project;
+        if (!scopeConfig) {
+            continue;
+        }
+        let root = scopeConfig.root;
+        if (mode === "project") {
+            if (!projectRoot) {
+                throw new errors_1.AgentConfigError("Project root is required for project mode", errors_1.ExitCodes.Validation);
+            }
+            root = root.replace("<project-root>", projectRoot);
+        }
+        const resolvedRoot = (0, paths_1.resolvePath)(root, process.env);
+        for (const mapping of [...scopeConfig.files, ...profileFiles]) {
+            const source = (0, paths_1.resolveFromRoot)(sourceRoot, mapping.source);
+            const target = (0, paths_1.resolveFromRoot)(resolvedRoot, mapping.target);
+            mappings.push({
+                agent,
+                source,
+                target,
+                mode: linkMode
+            });
+        }
+    }
+    return mappings;
+}
+function getProfileFiles(config) {
+    const profileName = config.defaults.profile;
+    const profile = config.profiles?.[profileName];
+    return profile?.files ?? [];
+}
+async function resolveSyncMode(linkMode) {
+    if (linkMode !== "auto") {
+        return linkMode;
+    }
+    const canLink = await canCreateSymlink();
+    return canLink ? "link" : "copy";
+}
+async function canCreateSymlink() {
+    const tempRoot = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "agentconfig-"));
+    const source = path_1.default.join(tempRoot, "source");
+    const target = path_1.default.join(tempRoot, "target");
+    try {
+        await promises_1.default.writeFile(source, "test", "utf8");
+        await promises_1.default.symlink(source, target);
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+    finally {
+        await promises_1.default.rm(tempRoot, { recursive: true, force: true });
+    }
+}
+async function applyMapping(mapping, warnings) {
+    const sourceExists = await (0, filesystem_1.fileExists)(mapping.source);
+    if (!sourceExists) {
+        throw new errors_1.AgentConfigError(`Missing source: ${mapping.source}`, errors_1.ExitCodes.Validation);
+    }
+    if (mapping.mode === "copy") {
+        await applyCopyMapping(mapping);
+        return;
+    }
+    await (0, filesystem_1.ensureDir)(path_1.default.dirname(mapping.target));
+    try {
+        const sourceStat = await promises_1.default.lstat(mapping.source);
+        const existing = await getTargetInfo(mapping.target);
+        if (existing) {
+            if (existing.isSymlink) {
+                if (existing.linkTarget === mapping.source) {
+                    return;
+                }
+                await promises_1.default.unlink(mapping.target);
+            }
+            else if (existing.isDirectory) {
+                const removed = await removeEmptyDirectory(mapping.target);
+                if (!removed) {
+                    throw new errors_1.AgentConfigError(`Refusing to replace non-empty directory: ${mapping.target}`, errors_1.ExitCodes.Filesystem);
+                }
+            }
+            else {
+                await promises_1.default.unlink(mapping.target);
+            }
+        }
+        await promises_1.default.symlink(mapping.source, mapping.target, sourceStat.isDirectory() ? "dir" : "file");
+    }
+    catch (error) {
+        if (error instanceof errors_1.AgentConfigError) {
+            throw error;
+        }
+        warnings.push(`Symlink failed for ${mapping.target}; falling back to copy`);
+        await applyCopyMapping(mapping);
+    }
+}
+async function applyCopyMapping(mapping) {
+    const sourceStat = await promises_1.default.lstat(mapping.source);
+    const existing = await getTargetInfo(mapping.target);
+    if (sourceStat.isDirectory()) {
+        if (existing && !existing.isDirectory) {
+            await promises_1.default.unlink(mapping.target);
+        }
+        await (0, filesystem_1.copyFileOrDir)(mapping.source, mapping.target);
+        return;
+    }
+    if (existing?.isDirectory) {
+        const removed = await removeEmptyDirectory(mapping.target);
+        if (!removed) {
+            throw new errors_1.AgentConfigError(`Refusing to replace non-empty directory: ${mapping.target}`, errors_1.ExitCodes.Filesystem);
+        }
+    }
+    else if (existing) {
+        await promises_1.default.unlink(mapping.target);
+    }
+    await (0, filesystem_1.copyFileOrDir)(mapping.source, mapping.target);
+}
+async function getTargetInfo(target) {
+    try {
+        const stat = await promises_1.default.lstat(target);
+        if (stat.isSymbolicLink()) {
+            return {
+                isDirectory: false,
+                isSymlink: true,
+                linkTarget: await (0, filesystem_1.readLinkTarget)(target)
+            };
+        }
+        return {
+            isDirectory: stat.isDirectory(),
+            isSymlink: false,
+            linkTarget: null
+        };
+    }
+    catch (_error) {
+        return null;
+    }
+}
+async function removeEmptyDirectory(target) {
+    const entries = await promises_1.default.readdir(target);
+    if (entries.length > 0) {
+        return false;
+    }
+    await promises_1.default.rmdir(target);
+    return true;
+}
+function isManaged(target, state) {
+    if (!state) {
+        return false;
+    }
+    return Boolean(state.files[target]);
+}
+async function buildState(stateRoot, mode, projectRoot, mappings, previousState) {
+    const files = { ...(previousState?.files ?? {}) };
+    for (const mapping of mappings) {
+        const stat = await promises_1.default.lstat(mapping.target);
+        const isLink = stat.isSymbolicLink();
+        const modeValue = isLink ? "link" : "copy";
+        const record = {
+            path: mapping.target,
+            source: mapping.source,
+            agent: mapping.agent,
+            mode: modeValue,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            hash: modeValue === "copy" ? await (0, filesystem_1.hashFile)(mapping.target) : null,
+            linkTarget: modeValue === "link" ? await (0, filesystem_1.readLinkTarget)(mapping.target) : null
+        };
+        files[mapping.target] = record;
+    }
+    return {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        mode,
+        projectRoot,
+        files
+    };
+}

package/dist/templates.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultConfig = createDefaultConfig;
+function createDefaultConfig() {
+    return {
+        version: 1,
+        defaults: {
+            mode: "auto",
+            profile: "default",
+            sourceRoot: "${AGENTCONFIG_HOME:-~/.agentconfig}"
+        },
+        agents: {
+            claude: {
+                displayName: "Claude Code",
+                global: {
+                    root: "~/.claude",
+                    files: [
+                        { source: "agent.md", target: "CLAUDE.md" },
+                        { source: "skills/", target: "skills/" }
+                    ]
+                },
+                project: {
+                    root: "<project-root>",
+                    files: [
+                        { source: "agent.md", target: "CLAUDE.md" },
+                        { source: "rules/", target: ".claude/rules/" },
+                        { source: "skills/", target: ".claude/skills/" }
+                    ]
+                }
+            },
+            codex: {
+                displayName: "Codex CLI",
+                global: {
+                    root: "${CODEX_HOME:-~/.codex}",
+                    files: [
+                        { source: "agent.md", target: "AGENTS.md" },
+                        { source: "skills/", target: "skills/" }
+                    ]
+                },
+                project: {
+                    root: "<project-root>",
+                    files: [
+                        { source: "agent.md", target: "AGENTS.md" },
+                        { source: "skills/", target: ".codex/skills/" }
+                    ]
+                }
+            },
+            cursor: {
+                displayName: "Cursor",
+                global: {
+                    root: "~/.cursor",
+                    files: [{ source: "skills/", target: "skills/" }]
+                },
+                project: {
+                    root: "<project-root>",
+                    files: [
+                        { source: "agent.md", target: "AGENTS.md" },
+                        { source: "rules/", target: ".cursor/rules/" },
+                        { source: "skills/", target: ".cursor/skills/" }
+                    ]
+                }
+            },
+            opencode: {
+                displayName: "OpenCode",
+                global: {
+                    root: "~/.config/opencode",
+                    files: [
+                        { source: "agent.md", target: "AGENTS.md" },
+                        { source: "rules/", target: "rules/" },
+                        { source: "skills/", target: "skills/" }
+                    ]
+                },
+                project: {
+                    root: "<project-root>",
+                    files: [
+                        { source: "agent.md", target: "AGENTS.md" },
+                        { source: "rules/", target: ".opencode/rules/" },
+                        { source: "skills/", target: ".opencode/skills/" }
+                    ]
+                }
+            }
+        },
+        profiles: {
+            default: {
+                files: []
+            }
+        }
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@shruubi/agentconfig",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Sync a single agent config source to multiple coding agents",
   "license": "MIT",
-  "repository": "https://github.com/damonswayn/agentconfig",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/damonswayn/agentconfig.git"
+  },
   "type": "commonjs",
   "main": "dist/cli.js",
   "files": [