code-ai-installer 1.5.6 → 2.0.1

package/dist/domainResolver.js

@@ -0,0 +1,139 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { z } from "zod";
+/** Zod schema for domain.json manifest. */
+const domainManifestSchema = z.object({
+    id: z.enum(["development", "content"]),
+    name: z.string().min(1),
+    description: z.string().min(1),
+});
+/** All valid domain identifiers for normalization. */
+const VALID_DOMAIN_IDS = ["development", "content"];
+/**
+ * Scans domains/ directory and returns available domain descriptors.
+ * Returns empty array if domains/ doesn't exist or has no valid entries.
+ * @param packageRoot Resolved package root path.
+ * @returns Sorted array of domain descriptors with computed counts.
+ */
+export async function listDomains(packageRoot) {
+    const domainsDir = path.join(packageRoot, "domains");
+    if (!(await fs.pathExists(domainsDir))) {
+        return [];
+    }
+    const entries = await fs.readdir(domainsDir);
+    const descriptors = [];
+    for (const entry of entries) {
+        const domainDir = path.join(domainsDir, entry);
+        const manifestPath = path.join(domainDir, "domain.json");
+        if (!(await fs.pathExists(manifestPath))) {
+            continue;
+        }
+        const raw = await fs.readJson(manifestPath);
+        const parsed = domainManifestSchema.safeParse(raw);
+        if (!parsed.success) {
+            console.warn(`[domain] Invalid domain.json in ${manifestPath}: ${parsed.error.message}`);
+            continue;
+        }
+        const agentCount = await countAgentFiles(domainDir);
+        const skillCount = await countSkillFiles(domainDir);
+        descriptors.push({
+            id: parsed.data.id,
+            name: parsed.data.name,
+            description: parsed.data.description,
+            rootDir: domainDir,
+            agentCount,
+            skillCount,
+        });
+    }
+    return descriptors.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Resolves domain source root path, accounting for language.
+ * ru: domains/<id>/   |   en: domains/<id>/locales/en/
+ * @param args Resolution arguments.
+ * @returns Absolute domain source root path.
+ */
+export async function resolveDomainSourceRoot(args) {
+    const domainDir = path.join(args.packageRoot, "domains", args.domainId);
+    if (!(await fs.pathExists(domainDir))) {
+        throw new Error(`Domain directory not found: ${domainDir}`);
+    }
+    if (args.language === "en") {
+        return path.join(domainDir, "locales", "en");
+    }
+    return domainDir;
+}
+/**
+ * Validates raw user input and returns strict DomainId.
+ * @param rawDomain User input string.
+ * @returns Validated DomainId.
+ * @throws Error with available domains list if invalid.
+ */
+export function normalizeDomain(rawDomain) {
+    const normalized = rawDomain.trim().toLowerCase();
+    if (VALID_DOMAIN_IDS.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unknown domain ${JSON.stringify(rawDomain.trim())}. Available: ${VALID_DOMAIN_IDS.join(", ")}`);
+}
+/**
+ * Resolves effective source root and optional domain id considering domain mode.
+ * @param pkgRoot Resolved package root.
+ * @param rawDomain Optional raw domain from CLI.
+ * @param language Template language.
+ * @returns Effective source root path and domain id (undefined for legacy).
+ */
+export async function resolveDomainAwareRootWithId(pkgRoot, rawDomain, language) {
+    const domains = await listDomains(pkgRoot);
+    if (domains.length === 0) {
+        if (rawDomain) {
+            throw new Error("--domain specified but no domains found in source. Remove --domain for legacy mode.");
+        }
+        return { effectiveRoot: pkgRoot };
+    }
+    let domainId;
+    if (rawDomain) {
+        domainId = normalizeDomain(rawDomain);
+    }
+    else if (domains.length === 1) {
+        domainId = domains[0].id;
+    }
+    else {
+        const available = domains.map((d) => d.id).join(", ");
+        throw new Error(`Multiple domains available. Specify --domain. Available: ${available}`);
+    }
+    const effectiveRoot = await resolveDomainSourceRoot({ packageRoot: pkgRoot, domainId, language });
+    return { effectiveRoot, domainId };
+}
+/**
+ * Counts .md files in agents/ subdirectory of a domain.
+ * @param domainDir Domain root directory.
+ * @returns Number of agent markdown files.
+ */
+async function countAgentFiles(domainDir) {
+    const agentsDir = path.join(domainDir, "agents");
+    if (!(await fs.pathExists(agentsDir))) {
+        return 0;
+    }
+    const entries = await fs.readdir(agentsDir);
+    return entries.filter((e) => e.endsWith(".md")).length;
+}
+/**
+ * Counts skill directories containing SKILL.md in .agents/skills/.
+ * @param domainDir Domain root directory.
+ * @returns Number of skill directories with SKILL.md.
+ */
+async function countSkillFiles(domainDir) {
+    const skillsDir = path.join(domainDir, ".agents", "skills");
+    if (!(await fs.pathExists(skillsDir))) {
+        return 0;
+    }
+    const entries = await fs.readdir(skillsDir);
+    let count = 0;
+    for (const entry of entries) {
+        if (await fs.pathExists(path.join(skillsDir, entry, "SKILL.md"))) {
+            count++;
+        }
+    }
+    return count;
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import prompts from "prompts";
 import { Command } from "commander";
 import { loadSourceCatalog, listAgentNames, listSkillNames, resolveSelection } from "./catalog.js";
+import { listDomains, resolveDomainSourceRoot, normalizeDomain, resolveDomainAwareRootWithId } from "./domainResolver.js";
 import { runDoctor } from "./doctor.js";
 import { runInstall, runUninstall } from "./installer.js";
 import { error, info, success, warn } from "./logger.js";
@@ -21,6 +22,9 @@ const WIZARD_TEXT = {
         selectTemplateLanguage: "Select template language:",
         languageRu: "Russian (ru)",
         languageEn: "English (en)",
+        selectDomain: "Select domain:",
+        domainAutoSelected: "Using domain: %s",
+        noDomainError: "No domains found.",
         selectAiTarget: "Select AI target:",
         installWhere: "Where should files be installed?",
         currentFolder: "Current folder",
@@ -43,6 +47,9 @@ const WIZARD_TEXT = {
         selectTemplateLanguage: "Выбери язык шаблонов:",
         languageRu: "Русский (ru)",
         languageEn: "English (en)",
+        selectDomain: "Выбери домен:",
+        domainAutoSelected: "Домен: %s (единственный)",
+        noDomainError: "Домены не найдены.",
         selectAiTarget: "Выбери AI для установки:",
         installWhere: "Куда устанавливать?",
         currentFolder: "Текущая папка",
@@ -79,16 +86,18 @@ program
     .command("list")
     .description("List available bundled agents and skills")
     .option("--project-dir <path>", "Optional custom source root path")
+    .option("--domain <name>", "Domain name (development | content)")
     .option("--lang <lang>", "Template language: ru | en", "ru")
     .action(async (options) => {
     try {
         const language = normalizeLanguage(options.lang);
-        const projectDir = await resolveSourceRoot({
+        const pkgRoot = await resolveSourceRoot({
             projectDirOption: options.projectDir,
             cwd: process.cwd(),
             packageRoot,
             language,
         });
+        const { effectiveRoot: projectDir } = await resolveDomainAwareRootWithId(pkgRoot, options.domain, language);
         const catalog = await loadSourceCatalog(projectDir);
         const agents = listAgentNames(catalog);
         const skills = listSkillNames(catalog);
@@ -106,18 +115,20 @@ program
     .description("Check source and destination health before install")
     .requiredOption("--target <id>", "Target AI id")
     .option("--project-dir <path>", "Optional custom source root path")
+    .option("--domain <name>", "Domain name (development | content)")
     .option("--destination <path>", "Destination root (default: current directory)")
     .option("--lang <lang>", "Template language: ru | en", "ru")
     .action(async (options) => {
     try {
         const target = normalizeTarget(options.target);
         const language = normalizeLanguage(options.lang);
-        const projectDir = await resolveSourceRoot({
+        const pkgRoot = await resolveSourceRoot({
             projectDirOption: options.projectDir,
             cwd: process.cwd(),
             packageRoot,
             language,
         });
+        const { effectiveRoot: projectDir } = await resolveDomainAwareRootWithId(pkgRoot, options.domain, language);
         const destinationDir = path.resolve(options.destination ?? process.cwd());
         const report = await runDoctor(projectDir, destinationDir, target);
         info(`Source: ${projectDir}`);
@@ -147,6 +158,7 @@ program
     .description("Install selected agents and skills for target AI")
     .requiredOption("--target <id>", "Target AI id")
     .option("--project-dir <path>", "Optional custom source root path")
+    .option("--domain <name>", "Domain name (development | content)")
     .option("--destination <path>", "Destination root (default: current directory)")
     .option("--create-dir <name>", "Create child folder in current directory and install there")
     .option("--lang <lang>", "Template language: ru | en", "ru")
@@ -159,12 +171,13 @@ program
     try {
         const target = normalizeTarget(options.target);
         const language = normalizeLanguage(options.lang);
-        const projectDir = await resolveSourceRoot({
+        const pkgRoot = await resolveSourceRoot({
             projectDirOption: options.projectDir,
             cwd: process.cwd(),
             packageRoot,
             language,
         });
+        const { effectiveRoot: projectDir, domainId } = await resolveDomainAwareRootWithId(pkgRoot, options.domain, language);
         const baseDestination = path.resolve(options.destination ?? process.cwd());
         const destinationDir = options.createDir ? path.join(baseDestination, options.createDir) : baseDestination;
         const catalog = await loadSourceCatalog(projectDir);
@@ -177,6 +190,7 @@ program
         }
         const { state, result } = await runInstall({
             target,
+            ...(domainId ? { domain: domainId } : {}),
             projectDir,
             destinationDir,
             selectedAgents,
@@ -215,17 +229,19 @@ program
     .command("uninstall")
     .description("Uninstall previously installed files for target")
     .requiredOption("--target <id>", "Target AI id")
+    .option("--domain <name>", "Domain name (development | content)")
     .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 domainId = options.domain ? normalizeDomain(options.domain) : undefined;
         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);
+        const result = await runUninstall(destinationDir, target, dryRun, domainId);
         info(`Files removed/planned: ${result.removed.length}`);
         info(`Files missing: ${result.missing.length}`);
         if (dryRun) {
@@ -262,11 +278,39 @@ async function runInteractiveWizard() {
     }
     const language = normalizeLanguage(languageAnswer.language);
     const text = WIZARD_TEXT[language];
-    const sourceRoot = await resolveSourceRoot({
+    const pkgRoot = await resolveSourceRoot({
         cwd: process.cwd(),
         packageRoot,
         language,
     });
+    const domains = await listDomains(pkgRoot);
+    let selectedDomainId;
+    let sourceRoot;
+    if (domains.length === 0) {
+        sourceRoot = pkgRoot;
+    }
+    else if (domains.length === 1) {
+        selectedDomainId = domains[0].id;
+        info(text.domainAutoSelected.replace("%s", domains[0].name));
+        sourceRoot = await resolveDomainSourceRoot({ packageRoot: pkgRoot, domainId: selectedDomainId, language });
+    }
+    else {
+        const domainAnswer = await prompts({
+            type: "select",
+            name: "domain",
+            message: text.selectDomain,
+            choices: domains.map((d) => ({
+                title: `${d.name} — ${d.description} (${d.agentCount} agents, ${d.skillCount} skills)`,
+                value: d.id,
+            })),
+        });
+        if (!domainAnswer.domain) {
+            warn(text.cancelled);
+            return;
+        }
+        selectedDomainId = domainAnswer.domain;
+        sourceRoot = await resolveDomainSourceRoot({ packageRoot: pkgRoot, domainId: selectedDomainId, language });
+    }
     const catalog = await loadSourceCatalog(sourceRoot);
     const adapters = getPlatformAdapters();
     const targetAnswer = await prompts({
@@ -384,6 +428,7 @@ async function runInteractiveWizard() {
     }
     const { state, result } = await runInstall({
         target,
+        ...(selectedDomainId ? { domain: selectedDomainId } : {}),
         projectDir: sourceRoot,
         destinationDir,
         selectedAgents: agentsAnswer.selectedAgents,

package/dist/installer.d.ts

@@ -1,4 +1,4 @@
-import type { InstallOptions, InstallState } from "./types.js";
+import type { DomainId, InstallOptions, InstallState } from "./types.js";
 interface ApplyResult {
     plannedFiles: string[];
     writtenFiles: string[];
@@ -21,7 +21,7 @@ export declare function runInstall(options: InstallOptions): Promise<{
  * @param dryRun Dry-run flag.
  * @returns Deleted files list.
  */
-export declare function runUninstall(destinationDir: string, target: InstallState["target"], dryRun: boolean): Promise<{
+export declare function runUninstall(destinationDir: string, target: InstallState["target"], dryRun: boolean, domain?: DomainId): Promise<{
     removed: string[];
     missing: string[];
 }>;
@@ -29,7 +29,8 @@ export declare function runUninstall(destinationDir: string, target: InstallStat
  * Reads installation state file for target.
  * @param destinationDir Destination root.
  * @param target Target id.
+ * @param domain Optional domain id for domain-aware state lookup.
  * @returns Install state or null.
  */
-export declare function readInstallState(destinationDir: string, target: InstallState["target"]): Promise<InstallState | null>;
+export declare function readInstallState(destinationDir: string, target: InstallState["target"], domain?: DomainId): Promise<InstallState | null>;
 export {};

package/dist/installer.js

@@ -19,6 +19,7 @@ export async function runInstall(options) {
     });
     const state = {
         target: options.target,
+        ...(options.domain ? { domain: options.domain } : {}),
         installedAt: new Date().toISOString(),
         destinationDir: options.destinationDir,
         projectDir: options.projectDir,
@@ -46,10 +47,11 @@ export async function runInstall(options) {
  * @param dryRun Dry-run flag.
  * @returns Deleted files list.
  */
-export async function runUninstall(destinationDir, target, dryRun) {
-    const state = await readInstallState(destinationDir, target);
+export async function runUninstall(destinationDir, target, dryRun, domain) {
+    const state = await readInstallState(destinationDir, target, domain);
     if (!state) {
-        throw new Error(`No install state found for target ${target}.`);
+        const label = domain ? `target ${target}, domain ${domain}` : `target ${target}`;
+        throw new Error(`No install state found for ${label}.`);
     }
     const removed = [];
     const missing = [];
@@ -64,7 +66,7 @@ export async function runUninstall(destinationDir, target, dryRun) {
         removed.push(filePath);
     }
     if (!dryRun) {
-        await deleteInstallState(destinationDir, target);
+        await deleteInstallState(destinationDir, target, domain);
     }
     return { removed, missing };
 }
@@ -72,10 +74,11 @@ export async function runUninstall(destinationDir, target, dryRun) {
  * Reads installation state file for target.
  * @param destinationDir Destination root.
  * @param target Target id.
+ * @param domain Optional domain id for domain-aware state lookup.
  * @returns Install state or null.
  */
-export async function readInstallState(destinationDir, target) {
-    const stateFile = getStateFilePath(destinationDir, target);
+export async function readInstallState(destinationDir, target, domain) {
+    const stateFile = getStateFilePath(destinationDir, target, domain);
     if (!(await fs.pathExists(stateFile))) {
         return null;
     }
@@ -162,7 +165,7 @@ async function rollbackWrites(writtenFiles, backupMap) {
  * @param state Install state.
  */
 async function writeInstallState(state) {
-    const stateFile = getStateFilePath(state.destinationDir, state.target);
+    const stateFile = getStateFilePath(state.destinationDir, state.target, state.domain);
     await fs.ensureDir(path.dirname(stateFile));
     await fs.writeJson(stateFile, state, { spaces: 2 });
 }
@@ -170,9 +173,10 @@ async function writeInstallState(state) {
  * Deletes stored state file for the given target.
  * @param destinationDir Destination root.
  * @param target Target id.
+ * @param domain Optional domain id for domain-aware state lookup.
  */
-async function deleteInstallState(destinationDir, target) {
-    const stateFile = getStateFilePath(destinationDir, target);
+async function deleteInstallState(destinationDir, target, domain) {
+    const stateFile = getStateFilePath(destinationDir, target, domain);
     if (await fs.pathExists(stateFile)) {
         await fs.remove(stateFile);
     }
@@ -181,10 +185,12 @@ async function deleteInstallState(destinationDir, target) {
  * Returns absolute path to state file for the target.
  * @param destinationDir Destination root.
  * @param target Target id.
+ * @param domain Optional domain id for domain-aware state file naming.
  * @returns State file path.
  */
-function getStateFilePath(destinationDir, target) {
-    return path.join(destinationDir, ".code-ai-installer", "state", `${target}.json`);
+function getStateFilePath(destinationDir, target, domain) {
+    const fileName = domain ? `${target}--${domain}.json` : `${target}.json`;
+    return path.join(destinationDir, ".code-ai-installer", "state", fileName);
 }
 /**
  * Creates a timestamped backup directory for one install run.

package/dist/metadataAudit.js

@@ -24,8 +24,7 @@ async function auditOrchestrator(projectDir, target, errors, warnings) {
     const portableLabel = "[metadata:orchestrator]";
     const portable = await readYamlSidecar(portablePath, portableLabel, warnings, errors);
     if (portable) {
-        ensureValue(portable, "name", "web_development_orchestra", portablePath, errors, portableLabel);
-        ensureRequired(portable, ["display_name", "description", "default_prompt"], portablePath, errors, portableLabel);
+        ensureRequired(portable, ["name", "display_name", "description", "default_prompt"], portablePath, errors, portableLabel);
     }
     if (!(await fs.pathExists(vendorPath))) {
         warnings.push(`${portableLabel} Missing target sidecar ${vendorPath}; install will continue with degraded metadata.`);
@@ -51,10 +50,9 @@ async function auditOrchestrator(projectDir, target, errors, warnings) {
     if (!payload) {
         return;
     }
-    ensureValue(payload, "name", "web_development_orchestra", vendorPath, errors, portableLabel);
-    ensureRequired(payload, ["display_name", "description", "default_prompt"], vendorPath, errors, portableLabel);
+    ensureRequired(payload, ["name", "display_name", "description", "default_prompt"], vendorPath, errors, portableLabel);
     if (portable) {
-        compareValues(payload, portable, ["display_name", "description", "default_prompt"], vendorPath, portablePath, errors, portableLabel);
+        compareValues(payload, portable, ["name", "display_name", "description", "default_prompt"], vendorPath, portablePath, errors, portableLabel);
     }
 }
 async function auditSkills(catalog, target, errors, warnings) {

package/dist/sourceResolver.js

@@ -35,10 +35,23 @@ export async function resolveSourceRoot(args) {
 }
 /**
  * Checks whether directory contains required source assets.
+ * Accepts legacy root layout (AGENTS.md + agents/ + .agents/) OR
+ * domain layout (domains/ with at least one valid domain.json) OR both.
  * @param rootDir Candidate root directory.
  * @returns True when required assets are present.
  */
 async function isValidSourceRoot(rootDir) {
+    if (await hasLegacyLayout(rootDir)) {
+        return true;
+    }
+    return hasDomainsLayout(rootDir);
+}
+/**
+ * Checks for legacy root layout: AGENTS.md + agents/ + .agents/ with skills.
+ * @param rootDir Candidate root directory.
+ * @returns True when legacy assets are present.
+ */
+async function hasLegacyLayout(rootDir) {
     const orchestratorPath = path.join(rootDir, "AGENTS.md");
     const agentsDir = path.join(rootDir, "agents");
     const dotAgentsDir = path.join(rootDir, ".agents");
@@ -59,6 +72,25 @@ async function isValidSourceRoot(rootDir) {
     }
     return false;
 }
+/**
+ * Checks for domain layout: domains/ with at least one valid domain.json.
+ * @param rootDir Candidate root directory.
+ * @returns True when at least one valid domain exists.
+ */
+async function hasDomainsLayout(rootDir) {
+    const domainsDir = path.join(rootDir, "domains");
+    if (!(await fs.pathExists(domainsDir))) {
+        return false;
+    }
+    const entries = await fs.readdir(domainsDir);
+    for (const entry of entries) {
+        const manifestPath = path.join(domainsDir, entry, "domain.json");
+        if (await fs.pathExists(manifestPath)) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Returns bundled templates root for selected language.
  * @param packageRoot Installed package root.

package/dist/types.d.ts

@@ -3,6 +3,21 @@
  */
 export type TargetId = "vscode-copilot" | "claude" | "qwen-3.5" | "google-antugravity" | "gpt-codex";
 export type TemplateLanguage = "ru" | "en";
+/**
+ * Supported domain identifiers.
+ */
+export type DomainId = "development" | "content";
+/**
+ * Domain metadata loaded from domain.json manifest + dynamic counts.
+ */
+export interface DomainDescriptor {
+    id: DomainId;
+    name: string;
+    description: string;
+    rootDir: string;
+    agentCount: number;
+    skillCount: number;
+}
 /**
  * Defines one source file and destination path copy action.
  */
@@ -33,6 +48,7 @@ export interface SourceCatalog {
  */
 export interface InstallOptions {
     target: TargetId;
+    domain?: DomainId;
     projectDir: string;
     destinationDir: string;
     selectedAgents: string[];
@@ -46,6 +62,7 @@ export interface InstallOptions {
  */
 export interface InstallState {
     target: TargetId;
+    domain?: DomainId;
     installedAt: string;
     destinationDir: string;
     projectDir: string;