code-ai-installer 1.0.1

package/dist/index.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import path from "node:path";
+import prompts from "prompts";
+import { Command } from "commander";
+import { loadSourceCatalog, listAgentNames, listSkillNames, resolveSelection } from "./catalog.js";
+import { runDoctor } from "./doctor.js";
+import { runInstall, runUninstall } from "./installer.js";
+import { error, info, success, warn } from "./logger.js";
+import { getPlatformAdapters } from "./platforms/adapters.js";
+const program = new Command();
+program
+    .name("code-ai")
+    .description("Install code-ai agents and skills for AI coding assistants")
+    .version("1.0.0");
+program
+    .command("targets")
+    .description("List supported AI targets")
+    .action(() => {
+    const adapters = getPlatformAdapters();
+    for (const adapter of adapters) {
+        info(`${adapter.id} - ${adapter.label}`);
+        info(`  ${adapter.description}`);
+    }
+});
+program
+    .command("list")
+    .description("List available agents and skills from current repository")
+    .option("--project-dir <path>", "Project root path", process.cwd())
+    .action(async (options) => {
+    try {
+        const projectDir = path.resolve(options.projectDir);
+        const catalog = await loadSourceCatalog(projectDir);
+        const agents = listAgentNames(catalog);
+        const skills = listSkillNames(catalog);
+        info(`Agents (${agents.length}): ${agents.join(", ")}`);
+        info(`Skills (${skills.length}): ${skills.join(", ")}`);
+    }
+    catch (err) {
+        error(err.message);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("doctor")
+    .description("Check source and destination health before install")
+    .requiredOption("--target <id>", "Target AI id")
+    .option("--project-dir <path>", "Project root path", process.cwd())
+    .option("--destination <path>", "Destination root (default: project root)")
+    .action(async (options) => {
+    try {
+        const target = normalizeTarget(options.target);
+        const projectDir = path.resolve(options.projectDir);
+        const destinationDir = path.resolve(options.destination ?? projectDir);
+        const report = await runDoctor(projectDir, destinationDir, target);
+        for (const line of report.info) {
+            info(line);
+        }
+        for (const line of report.warnings) {
+            warn(line);
+        }
+        for (const line of report.errors) {
+            error(line);
+        }
+        if (report.errors.length > 0) {
+            process.exitCode = 1;
+        }
+        else {
+            success("Doctor checks passed.");
+        }
+    }
+    catch (err) {
+        error(err.message);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("install")
+    .description("Install selected agents and skills for target AI")
+    .requiredOption("--target <id>", "Target AI id")
+    .option("--project-dir <path>", "Project root path", process.cwd())
+    .option("--destination <path>", "Destination root (default: project root)")
+    .option("--agents <list>", "Comma list of agents or 'all'", "all")
+    .option("--skills <list>", "Comma list of skills or 'all'", "all")
+    .option("--overwrite", "Overwrite existing files", false)
+    .option("--strict-hints", "Require explicit target-native hints in agent/skill files", false)
+    .option("--apply", "Execute file writes (default is dry-run)", false)
+    .action(async (options) => {
+    try {
+        const target = normalizeTarget(options.target);
+        const projectDir = path.resolve(options.projectDir);
+        const destinationDir = path.resolve(options.destination ?? projectDir);
+        const catalog = await loadSourceCatalog(projectDir);
+        const selectedAgents = resolveSelection(options.agents, listAgentNames(catalog), "agents");
+        const selectedSkills = resolveSelection(options.skills, listSkillNames(catalog), "skills");
+        const dryRun = !options.apply;
+        const overwriteMode = options.overwrite ? "overwrite" : "skip";
+        if (dryRun) {
+            warn("Running in dry-run mode. Use --apply to write files.");
+        }
+        const { state, result } = await runInstall({
+            target,
+            projectDir,
+            destinationDir,
+            selectedAgents,
+            selectedSkills,
+            dryRun,
+            overwriteMode,
+            strictHints: options.strictHints,
+        });
+        info(`Target: ${state.target}`);
+        info(`Destination: ${state.destinationDir}`);
+        info(`Files planned: ${result.plannedFiles.length}`);
+        if (dryRun) {
+            info(`Files would write: ${result.writtenFiles.length}`);
+        }
+        else {
+            info(`Files written: ${result.writtenFiles.length}`);
+        }
+        info(`Files skipped: ${result.skippedFiles.length}`);
+        if (result.backupDir) {
+            info(`Backup: ${result.backupDir}`);
+        }
+        if (dryRun) {
+            success("Dry-run completed.");
+        }
+        else {
+            success("Install completed.");
+        }
+    }
+    catch (err) {
+        error(err.message);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("uninstall")
+    .description("Uninstall previously installed files for target")
+    .requiredOption("--target <id>", "Target AI id")
+    .option("--destination <path>", "Destination root", process.cwd())
+    .option("--apply", "Execute delete operations (default is dry-run)", false)
+    .action(async (options) => {
+    try {
+        const target = normalizeTarget(options.target);
+        const destinationDir = path.resolve(options.destination);
+        const dryRun = !options.apply;
+        if (dryRun) {
+            warn("Running in dry-run mode. Use --apply to remove files.");
+        }
+        const result = await runUninstall(destinationDir, target, dryRun);
+        info(`Files removed/planned: ${result.removed.length}`);
+        info(`Files missing: ${result.missing.length}`);
+        if (dryRun) {
+            success("Uninstall dry-run completed.");
+        }
+        else {
+            success("Uninstall completed.");
+        }
+    }
+    catch (err) {
+        error(err.message);
+        process.exitCode = 1;
+    }
+});
+/**
+ * Runs interactive installer workflow when no subcommand is provided.
+ */
+async function runInteractiveWizard() {
+    const projectDir = process.cwd();
+    const catalog = await loadSourceCatalog(projectDir);
+    const adapters = getPlatformAdapters();
+    const targetAnswer = await prompts({
+        type: "select",
+        name: "target",
+        message: "Выбери AI для установки:",
+        choices: adapters.map((adapter) => ({
+            title: `${adapter.label} (${adapter.id})`,
+            value: adapter.id,
+            description: adapter.description,
+        })),
+    });
+    if (!targetAnswer.target) {
+        warn("Установка отменена.");
+        return;
+    }
+    const destinationAnswer = await prompts({
+        type: "text",
+        name: "destination",
+        message: "Папка установки:",
+        initial: projectDir,
+        validate: (value) => (value.trim().length === 0 ? "Укажи путь" : true),
+    });
+    if (!destinationAnswer.destination) {
+        warn("Установка отменена.");
+        return;
+    }
+    const agents = listAgentNames(catalog);
+    const skills = listSkillNames(catalog);
+    const agentsAnswer = await prompts({
+        type: "multiselect",
+        name: "selectedAgents",
+        message: "Выбери агентов:",
+        choices: agents.map((agentName) => ({ title: agentName, value: agentName, selected: true })),
+        min: 1,
+        hint: "space: выбрать, enter: подтвердить",
+    });
+    if (!agentsAnswer.selectedAgents || agentsAnswer.selectedAgents.length === 0) {
+        warn("Установка отменена.");
+        return;
+    }
+    const skillsAnswer = await prompts({
+        type: "multiselect",
+        name: "selectedSkills",
+        message: "Выбери skills:",
+        choices: skills.map((skillName) => ({ title: skillName, value: skillName, selected: true })),
+        min: 1,
+        hint: "space: выбрать, enter: подтвердить",
+    });
+    if (!skillsAnswer.selectedSkills || skillsAnswer.selectedSkills.length === 0) {
+        warn("Установка отменена.");
+        return;
+    }
+    const optionsAnswer = await prompts([
+        {
+            type: "toggle",
+            name: "overwrite",
+            message: "Перезаписывать существующие файлы?",
+            initial: false,
+            active: "yes",
+            inactive: "no",
+        },
+        {
+            type: "toggle",
+            name: "apply",
+            message: "Сразу выполнить установку?",
+            initial: true,
+            active: "yes",
+            inactive: "no",
+        },
+        {
+            type: "toggle",
+            name: "strictHints",
+            message: "Требовать явные target-hints в agent/skill файлах?",
+            initial: false,
+            active: "yes",
+            inactive: "no",
+        },
+    ]);
+    const target = targetAnswer.target;
+    const destinationDir = path.resolve(destinationAnswer.destination);
+    info("Запускаю doctor перед установкой...");
+    const doctor = await runDoctor(projectDir, destinationDir, target);
+    for (const line of doctor.info) {
+        info(line);
+    }
+    for (const line of doctor.warnings) {
+        warn(line);
+    }
+    for (const line of doctor.errors) {
+        error(line);
+    }
+    if (doctor.errors.length > 0) {
+        throw new Error("Doctor не пройден. Исправь ошибки и запусти снова.");
+    }
+    const dryRun = !Boolean(optionsAnswer.apply);
+    const overwriteMode = optionsAnswer.overwrite ? "overwrite" : "skip";
+    if (dryRun) {
+        warn("Выбран preview-режим без записи файлов.");
+    }
+    const { state, result } = await runInstall({
+        target,
+        projectDir,
+        destinationDir,
+        selectedAgents: agentsAnswer.selectedAgents,
+        selectedSkills: skillsAnswer.selectedSkills,
+        dryRun,
+        overwriteMode,
+        strictHints: Boolean(optionsAnswer.strictHints),
+    });
+    info(`Target: ${state.target}`);
+    info(`Destination: ${state.destinationDir}`);
+    info(`Files planned: ${result.plannedFiles.length}`);
+    if (dryRun) {
+        info(`Files would write: ${result.writtenFiles.length}`);
+        success("Preview completed.");
+    }
+    else {
+        info(`Files written: ${result.writtenFiles.length}`);
+        if (result.backupDir) {
+            info(`Backup: ${result.backupDir}`);
+        }
+        success("Install completed.");
+    }
+}
+/**
+ * Normalizes user target aliases into strict target identifiers.
+ * @param rawTarget Raw target value from CLI.
+ * @returns Normalized target id.
+ */
+function normalizeTarget(rawTarget) {
+    const value = rawTarget.trim().toLowerCase();
+    const aliasMap = {
+        "vscode-copilot": "vscode-copilot",
+        copilot: "vscode-copilot",
+        "gpt-codex": "gpt-codex",
+        codex: "gpt-codex",
+        gptcodex: "gpt-codex",
+        claude: "claude",
+        "qwen-3.5": "qwen-3.5",
+        qwen: "qwen-3.5",
+        "google-antugravity": "google-antugravity",
+        "google-antigravity": "google-antugravity",
+        antugravity: "google-antugravity",
+        antigravity: "google-antugravity",
+        google: "google-antugravity",
+    };
+    const normalized = aliasMap[value];
+    if (!normalized) {
+        throw new Error(`Unsupported target '${rawTarget}'. Run 'code-ai targets' for full list.`);
+    }
+    return normalized;
+}
+if (process.argv.length <= 2) {
+    runInteractiveWizard().catch((err) => {
+        error(err.message);
+        process.exit(1);
+    });
+}
+else {
+    program.parseAsync(process.argv).catch((err) => {
+        error(err.message);
+        process.exit(1);
+    });
+}

package/dist/installer.d.ts

@@ -0,0 +1,35 @@
+import type { InstallOptions, InstallState } from "./types.js";
+interface ApplyResult {
+    plannedFiles: string[];
+    writtenFiles: string[];
+    skippedFiles: string[];
+    backupDir?: string;
+}
+/**
+ * Runs installation for selected target with optional dry-run and backup.
+ * @param options Install options.
+ * @returns Install state and write summary.
+ */
+export declare function runInstall(options: InstallOptions): Promise<{
+    state: InstallState;
+    result: ApplyResult;
+}>;
+/**
+ * Executes uninstall by reading and deleting previously installed files.
+ * @param destinationDir Destination root where state is stored.
+ * @param target Target id.
+ * @param dryRun Dry-run flag.
+ * @returns Deleted files list.
+ */
+export declare function runUninstall(destinationDir: string, target: InstallState["target"], dryRun: boolean): Promise<{
+    removed: string[];
+    missing: string[];
+}>;
+/**
+ * Reads installation state file for target.
+ * @param destinationDir Destination root.
+ * @param target Target id.
+ * @returns Install state or null.
+ */
+export declare function readInstallState(destinationDir: string, target: InstallState["target"]): Promise<InstallState | null>;
+export {};

package/dist/installer.js

@@ -0,0 +1,205 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { getPlatformAdapter } from "./platforms/adapters.js";
+import { loadSourceCatalog } from "./catalog.js";
+import { hasExplicitTargetHint, transformContentForTarget } from "./contentTransformer.js";
+/**
+ * Runs installation for selected target with optional dry-run and backup.
+ * @param options Install options.
+ * @returns Install state and write summary.
+ */
+export async function runInstall(options) {
+    const catalog = await loadSourceCatalog(options.projectDir);
+    const adapter = getPlatformAdapter(options.target);
+    const operations = adapter.planOperations({
+        catalog,
+        destinationDir: options.destinationDir,
+        selectedAgents: options.selectedAgents,
+        selectedSkills: options.selectedSkills,
+    });
+    const state = {
+        target: options.target,
+        installedAt: new Date().toISOString(),
+        destinationDir: options.destinationDir,
+        projectDir: options.projectDir,
+        files: operations.map((op) => op.destinationPath),
+        selectedAgents: options.selectedAgents,
+        selectedSkills: options.selectedSkills,
+    };
+    const result = await applyOperations({
+        operations,
+        overwriteMode: options.overwriteMode,
+        dryRun: options.dryRun,
+        destinationDir: options.destinationDir,
+        target: options.target,
+        strictHints: options.strictHints,
+    });
+    if (!options.dryRun) {
+        await writeInstallState(state);
+    }
+    return { state, result };
+}
+/**
+ * Executes uninstall by reading and deleting previously installed files.
+ * @param destinationDir Destination root where state is stored.
+ * @param target Target id.
+ * @param dryRun Dry-run flag.
+ * @returns Deleted files list.
+ */
+export async function runUninstall(destinationDir, target, dryRun) {
+    const state = await readInstallState(destinationDir, target);
+    if (!state) {
+        throw new Error(`No install state found for target ${target}.`);
+    }
+    const removed = [];
+    const missing = [];
+    for (const filePath of state.files) {
+        if (!(await fs.pathExists(filePath))) {
+            missing.push(filePath);
+            continue;
+        }
+        if (!dryRun) {
+            await fs.remove(filePath);
+        }
+        removed.push(filePath);
+    }
+    if (!dryRun) {
+        await deleteInstallState(destinationDir, target);
+    }
+    return { removed, missing };
+}
+/**
+ * Reads installation state file for target.
+ * @param destinationDir Destination root.
+ * @param target Target id.
+ * @returns Install state or null.
+ */
+export async function readInstallState(destinationDir, target) {
+    const stateFile = getStateFilePath(destinationDir, target);
+    if (!(await fs.pathExists(stateFile))) {
+        return null;
+    }
+    return fs.readJson(stateFile);
+}
+/**
+ * Performs planned operations with backup and rollback semantics.
+ * @param args Execution settings.
+ * @returns Apply result summary.
+ */
+async function applyOperations(args) {
+    const plannedFiles = [];
+    const writtenFiles = [];
+    const skippedFiles = [];
+    const backupMap = new Map();
+    let backupDir;
+    if (!args.dryRun) {
+        backupDir = await createBackupDir(args.destinationDir, args.target);
+    }
+    try {
+        for (const operation of args.operations) {
+            const destination = operation.destinationPath;
+            plannedFiles.push(destination);
+            const exists = await fs.pathExists(destination);
+            if (exists && args.overwriteMode === "skip") {
+                skippedFiles.push(destination);
+                continue;
+            }
+            let sourceContentForTransform;
+            if (operation.transform &&
+                args.strictHints &&
+                (operation.transform.assetType === "agent" || operation.transform.assetType === "skill")) {
+                sourceContentForTransform = await fs.readFile(operation.sourcePath, "utf8");
+                if (!hasExplicitTargetHint(sourceContentForTransform, operation.transform.target)) {
+                    throw new Error(`Strict hints check failed: missing explicit '${operation.transform.target}' hint in ${operation.sourcePath}`);
+                }
+            }
+            if (!args.dryRun && exists && backupDir) {
+                const rel = path.relative(args.destinationDir, destination);
+                const backupPath = path.join(backupDir, rel);
+                await fs.ensureDir(path.dirname(backupPath));
+                await fs.copy(destination, backupPath, { overwrite: true });
+                backupMap.set(destination, backupPath);
+            }
+            if (!args.dryRun) {
+                await fs.ensureDir(path.dirname(destination));
+                if (operation.generated) {
+                    await fs.writeFile(destination, operation.content ?? "", "utf8");
+                }
+                else if (operation.transform) {
+                    const sourceContent = sourceContentForTransform ?? (await fs.readFile(operation.sourcePath, "utf8"));
+                    const transformed = transformContentForTarget(sourceContent, operation.transform.target, operation.transform.assetType);
+                    await fs.writeFile(destination, transformed, "utf8");
+                }
+                else {
+                    await fs.copy(operation.sourcePath, destination, { overwrite: true });
+                }
+            }
+            writtenFiles.push(destination);
+        }
+    }
+    catch (error) {
+        if (!args.dryRun) {
+            await rollbackWrites(writtenFiles, backupMap);
+        }
+        throw error;
+    }
+    return { plannedFiles, writtenFiles, skippedFiles, backupDir };
+}
+/**
+ * Rolls back written files from backup map when apply fails.
+ * @param writtenFiles Files that were written in current transaction.
+ * @param backupMap Existing-file backup mapping.
+ */
+async function rollbackWrites(writtenFiles, backupMap) {
+    for (const destination of writtenFiles.slice().reverse()) {
+        const backupPath = backupMap.get(destination);
+        if (backupPath && (await fs.pathExists(backupPath))) {
+            await fs.copy(backupPath, destination, { overwrite: true });
+            continue;
+        }
+        if (await fs.pathExists(destination)) {
+            await fs.remove(destination);
+        }
+    }
+}
+/**
+ * Writes install state for future uninstall operations.
+ * @param state Install state.
+ */
+async function writeInstallState(state) {
+    const stateFile = getStateFilePath(state.destinationDir, state.target);
+    await fs.ensureDir(path.dirname(stateFile));
+    await fs.writeJson(stateFile, state, { spaces: 2 });
+}
+/**
+ * Deletes stored state file for the given target.
+ * @param destinationDir Destination root.
+ * @param target Target id.
+ */
+async function deleteInstallState(destinationDir, target) {
+    const stateFile = getStateFilePath(destinationDir, target);
+    if (await fs.pathExists(stateFile)) {
+        await fs.remove(stateFile);
+    }
+}
+/**
+ * Returns absolute path to state file for the target.
+ * @param destinationDir Destination root.
+ * @param target Target id.
+ * @returns State file path.
+ */
+function getStateFilePath(destinationDir, target) {
+    return path.join(destinationDir, ".code-ai-installer", "state", `${target}.json`);
+}
+/**
+ * Creates a timestamped backup directory for one install run.
+ * @param destinationDir Destination root.
+ * @param target Target id.
+ * @returns Backup directory path.
+ */
+async function createBackupDir(destinationDir, target) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupDir = path.join(destinationDir, ".code-ai-installer", "backups", target, timestamp);
+    await fs.ensureDir(backupDir);
+    return backupDir;
+}

package/dist/logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Prints informational line.
+ * @param message Message text.
+ */
+export declare function info(message: string): void;
+/**
+ * Prints warning line.
+ * @param message Message text.
+ */
+export declare function warn(message: string): void;
+/**
+ * Prints error line.
+ * @param message Message text.
+ */
+export declare function error(message: string): void;
+/**
+ * Prints success line.
+ * @param message Message text.
+ */
+export declare function success(message: string): void;

package/dist/logger.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+/**
+ * Prints informational line.
+ * @param message Message text.
+ */
+export function info(message) {
+    process.stdout.write(`${chalk.cyan("info")} ${message}\n`);
+}
+/**
+ * Prints warning line.
+ * @param message Message text.
+ */
+export function warn(message) {
+    process.stdout.write(`${chalk.yellow("warn")} ${message}\n`);
+}
+/**
+ * Prints error line.
+ * @param message Message text.
+ */
+export function error(message) {
+    process.stderr.write(`${chalk.red("error")} ${message}\n`);
+}
+/**
+ * Prints success line.
+ * @param message Message text.
+ */
+export function success(message) {
+    process.stdout.write(`${chalk.green("ok")} ${message}\n`);
+}

package/dist/platforms/adapters.d.ts

@@ -0,0 +1,12 @@
+import type { PlatformAdapter, TargetId } from "../types.js";
+/**
+ * Returns all supported platform adapters.
+ * @returns Array of platform adapters.
+ */
+export declare function getPlatformAdapters(): PlatformAdapter[];
+/**
+ * Returns a single platform adapter by identifier.
+ * @param target Target id.
+ * @returns Platform adapter.
+ */
+export declare function getPlatformAdapter(target: TargetId): PlatformAdapter;