@copado/agentia-cli 0.122.0-alpha.0 → 1.0.0-beta.0

package/dist/lib/sdr-path-resolver.js

@@ -1,116 +1,4 @@
-import { SDR_BUNDLE_TYPES, SDR_OBJECT_CHILDREN, SDR_SUFFIX_TYPES, } from './sdr-metadata-registry.generated.js';
-const SORTED_SUFFIX_KEYS = Object.keys(SDR_SUFFIX_TYPES).sort((left, right) => right.length - left.length || left.localeCompare(right));
-function pathSegments(path) {
-    return path.split('/').filter(Boolean);
-}
-function pathIncludesDirectory(path, directoryName, strictDirectoryName) {
-    if (!directoryName) {
-        return true;
-    }
-    const segments = pathSegments(path);
-    if (strictDirectoryName) {
-        return segments.includes(directoryName);
-    }
-    return segments.includes(directoryName) || path.includes(`/${directoryName}/`);
-}
-function suffixTail(value, suffix) {
-    const normalizedSuffix = suffix.startsWith('.') ? suffix : `.${suffix}`;
-    if (!value.endsWith(normalizedSuffix)) {
-        return undefined;
-    }
-    const name = value.slice(0, -normalizedSuffix.length);
-    return name.length > 0 ? name : undefined;
-}
-function resolveCustomObjectPath(path) {
-    if (!path.includes('/objects/')) {
-        return undefined;
-    }
-    const objectRootMatch = path.match(/\/objects\/([^/]+)\/\1\.object-meta\.xml$/);
-    if (objectRootMatch) {
-        return { name: objectRootMatch[1], type: 'CustomObject' };
-    }
-    const childMatch = path.match(/\/objects\/([^/]+)\/([^/]+)\/(.+)-meta\.xml$/);
-    if (!childMatch) {
-        return undefined;
-    }
-    const [, objectName, childDirectoryName, fileStem] = childMatch;
-    const child = SDR_OBJECT_CHILDREN[childDirectoryName];
-    if (!child) {
-        return undefined;
-    }
-    const childName = suffixTail(fileStem, child.suffix);
-    if (!childName) {
-        return undefined;
-    }
-    const name = child.ignoreParentName ? childName : `${objectName}.${childName}`;
-    return { name, type: child.typeName };
-}
-function resolveBundlePath(path) {
-    const segments = pathSegments(path);
-    for (const type of SDR_BUNDLE_TYPES) {
-        const directoryIndex = segments.indexOf(type.directoryName);
-        if (directoryIndex === -1) {
-            continue;
-        }
-        const bundleName = segments[directoryIndex + 1];
-        if (!bundleName || bundleName.includes('.')) {
-            continue;
-        }
-        return { name: bundleName, type: type.name };
-    }
-    return undefined;
-}
-function resolveContentSuffixPath(path) {
-    const fileName = path.split('/').pop() ?? '';
-    if (!fileName || fileName.endsWith('-meta.xml')) {
-        return undefined;
-    }
-    for (const suffixKey of SORTED_SUFFIX_KEYS) {
-        const type = SDR_SUFFIX_TYPES[suffixKey];
-        if (!type.suffix || type.adapter !== 'matchingContentFile') {
-            continue;
-        }
-        const childName = suffixTail(fileName, type.suffix);
-        if (!childName) {
-            continue;
-        }
-        if (!pathIncludesDirectory(path, type.directoryName, type.strictDirectoryName)) {
-            continue;
-        }
-        return { name: childName, type: type.name };
-    }
-    return undefined;
-}
-function resolveMetaXmlPath(path) {
-    const fileName = path.split('/').pop() ?? '';
-    if (!fileName.endsWith('-meta.xml')) {
-        return undefined;
-    }
-    for (const suffixKey of SORTED_SUFFIX_KEYS) {
-        const type = SDR_SUFFIX_TYPES[suffixKey];
-        if (!type.suffix) {
-            continue;
-        }
-        const componentName = suffixTail(fileName, `${type.suffix}-meta.xml`);
-        if (!componentName) {
-            continue;
-        }
-        if (!pathIncludesDirectory(path, type.directoryName, type.strictDirectoryName)) {
-            continue;
-        }
-        return { name: componentName, type: type.name };
-    }
-    return undefined;
-}
-export function resolveSalesforcePath(path) {
-    const normalizedPath = path.replaceAll('\\', '/');
-    return (resolveCustomObjectPath(normalizedPath) ??
-        resolveBundlePath(normalizedPath) ??
-        resolveContentSuffixPath(normalizedPath) ??
-        resolveMetaXmlPath(normalizedPath));
-}
-// Test-only helper for validating registry coverage.
-export function listRegistryBundleTypes() {
-    return SDR_BUNDLE_TYPES;
-}
-//# sourceMappingURL=sdr-path-resolver.js.map
+import {modules} from './runtime.js';
+const listRegistryBundleTypes = modules["sdr-path-resolver.js"]["listRegistryBundleTypes"]
+const resolveSalesforcePath = modules["sdr-path-resolver.js"]["resolveSalesforcePath"]
+export {listRegistryBundleTypes, resolveSalesforcePath};

package/dist/lib/secret-redaction.js

@@ -1,24 +1,4 @@
-const REDACTED = '[REDACTED]';
-const SENSITIVE_KEY_PATTERN = /(access.?token|refresh.?token|session.?id|api.?key|apikey|password|secret|authorization|bearer|signature|extra.?headers|oauth.?signature)/i;
-const BEARER_VALUE_PATTERN = /Bearer\s+[\w.~+/=-]+/gi;
-export function redactSecrets(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => redactSecrets(item));
-    }
-    if (value && typeof value === 'object') {
-        const result = {};
-        for (const [key, nested] of Object.entries(value)) {
-            result[key] = SENSITIVE_KEY_PATTERN.test(key) ? REDACTED : redactSecrets(nested);
-        }
-        return result;
-    }
-    if (typeof value === 'string') {
-        return value.replaceAll(BEARER_VALUE_PATTERN, `Bearer ${REDACTED}`);
-    }
-    return value;
-}
-export function redactErrorMessage(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return redactSecrets(message);
-}
-//# sourceMappingURL=secret-redaction.js.map
+import {modules} from './runtime.js';
+const redactErrorMessage = modules["secret-redaction.js"]["redactErrorMessage"]
+const redactSecrets = modules["secret-redaction.js"]["redactSecrets"]
+export {redactErrorMessage, redactSecrets};

package/dist/lib/setup-prompts.js

@@ -1,14 +1,4 @@
-import { checkbox, confirm, input, password, select } from '@inquirer/prompts';
-export function isPromptCanceled(error) {
-    return typeof error === 'object' && error !== null && error.name === 'ExitPromptError';
-}
-export function createInquirerSetupPrompts() {
-    return {
-        checkbox: (options) => checkbox(options),
-        confirm: (options) => confirm(options),
-        input: (options) => input(options),
-        password: (options) => password({ ...options, mask: true }),
-        select: (options) => select(options),
-    };
-}
-//# sourceMappingURL=setup-prompts.js.map
+import {modules} from './runtime.js';
+const createInquirerSetupPrompts = modules["setup-prompts.js"]["createInquirerSetupPrompts"]
+const isPromptCanceled = modules["setup-prompts.js"]["isPromptCanceled"]
+export {createInquirerSetupPrompts, isPromptCanceled};

package/dist/lib/setup-skills.js

@@ -1,263 +1,16 @@
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolveProjectContext } from './project-setup.js';
-export const SETUP_SKILL_MANAGED_MARKER = '<!-- Agentia managed skill file: agentia setup skills -->';
-export const SETUP_SKILL_PACKS = ['cicd', 'testing', 'ai'];
-export const SETUP_SKILL_TARGETS = ['agents', 'cursor', 'claude'];
-const DEFAULT_TARGET = 'agents';
-const TARGET_DIRS = {
-    agents: '.agents/skills',
-    claude: '.claude/skills',
-    cursor: '.cursor/skills',
-};
-const PACK_SKILL_DIRS = {
-    ai: 'agentia-ai',
-    cicd: 'agentia-cicd',
-    testing: 'agentia-testing',
-};
-const TEMPLATE_MANIFEST = [
-    { pack: 'cicd', path: 'agentia-cicd/SKILL.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/work.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/promotions.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/jobs.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/environments-and-credentials.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/pipelines.md' },
-    { pack: 'cicd', path: 'agentia-cicd/references/data.md' },
-    { pack: 'testing', path: 'agentia-testing/SKILL.md' },
-    { pack: 'testing', path: 'agentia-testing/references/tests.md' },
-    { pack: 'ai', path: 'agentia-ai/SKILL.md' },
-    { pack: 'ai', path: 'agentia-ai/references/ai-agents.md' },
-];
-let testDeps;
-export function setSetupSkillsDepsForTests(deps) {
-    testDeps = deps;
-}
-export function resetSetupSkillsDepsForTests() {
-    testDeps = undefined;
-}
-function templatesRoot() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/skills');
-}
-function resolveDeps(overrides = {}) {
-    const merged = { ...testDeps, ...overrides };
-    return {
-        existsSync: merged.existsSync ?? existsSync,
-        getCurrentBranch: merged.getCurrentBranch,
-        getGitRepoRoot: merged.getGitRepoRoot,
-        getRemoteUrl: merged.getRemoteUrl,
-        isInsideGitWorkTree: merged.isInsideGitWorkTree,
-        mkdir: merged.mkdir ?? ((dirPath, options) => mkdir(dirPath, options)),
-        prompts: merged.prompts,
-        readFile: merged.readFile ?? ((filePath, encoding) => readFile(filePath, encoding)),
-        readTemplateFile: merged.readTemplateFile ??
-            ((relativePath) => readFile(path.join(templatesRoot(), relativePath), 'utf8')),
-        templates: merged.templates,
-        writeFile: merged.writeFile ?? ((filePath, contents, encoding) => writeFile(filePath, contents, encoding)),
-    };
-}
-export function formatSetupSkillPack(pack) {
-    if (pack === 'cicd') {
-        return 'CICD';
-    }
-    if (pack === 'ai') {
-        return 'AI';
-    }
-    return 'Testing';
-}
-export function isSetupSkillPack(value) {
-    return SETUP_SKILL_PACKS.includes(value);
-}
-export function isSetupSkillTarget(value) {
-    return SETUP_SKILL_TARGETS.includes(value);
-}
-export function resolveSelectedSkillPacks(flags) {
-    const selected = SETUP_SKILL_PACKS.filter((pack) => flags[pack] === true);
-    return selected.length > 0 ? selected : [...SETUP_SKILL_PACKS];
-}
-export function skillRootDirectory(target) {
-    return TARGET_DIRS[target];
-}
-export function skillDirectoryForPack(pack) {
-    return PACK_SKILL_DIRS[pack];
-}
-export async function resolveSetupSkillTargets(options) {
-    const { noPrompt = false, prompts, targets } = options;
-    if (targets !== undefined && targets.length > 0) {
-        return [...new Set(targets)];
-    }
-    if (noPrompt || prompts === undefined) {
-        return [DEFAULT_TARGET];
-    }
-    if (prompts.checkbox === undefined) {
-        return [await prompts.select({
-                choices: [
-                    { name: '.agents/skills (portable Agent Skills)', value: 'agents' },
-                    { name: '.cursor/skills (Cursor project skills)', value: 'cursor' },
-                    { name: '.claude/skills (Claude compatibility)', value: 'claude' },
-                ],
-                default: DEFAULT_TARGET,
-                message: 'Where should Agentia skills be created?',
-            })];
-    }
-    const selected = await prompts.checkbox({
-        choices: [
-            { checked: true, name: '.agents/skills (portable Agent Skills)', value: 'agents' },
-            { name: '.cursor/skills (Cursor project skills)', value: 'cursor' },
-            { name: '.claude/skills (Claude compatibility)', value: 'claude' },
-        ],
-        message: 'Where should Agentia skills be created?',
-    });
-    if (selected.length === 0)
-        throw new Error('Select at least one skill target.');
-    return SETUP_SKILL_TARGETS.filter((target) => selected.includes(target));
-}
-/** @deprecated Use {@link resolveSetupSkillTargets}. */
-export async function resolveSetupSkillTarget(options) {
-    const targets = await resolveSetupSkillTargets({ ...options, targets: options.target ? [options.target] : undefined });
-    return targets[0] ?? DEFAULT_TARGET;
-}
-async function loadTemplates(deps) {
-    if (deps.templates !== undefined) {
-        return deps.templates;
-    }
-    return Promise.all(TEMPLATE_MANIFEST.map(async (entry) => ({
-        content: await deps.readTemplateFile(entry.path),
-        pack: entry.pack,
-        relativePath: entry.path,
-    })));
-}
-function containsManagedMarker(content) {
-    return content.includes(SETUP_SKILL_MANAGED_MARKER);
-}
-function summarizeStatus(files) {
-    if (files.some((file) => file.status === 'updated')) {
-        return 'updated';
-    }
-    if (files.some((file) => file.status === 'created')) {
-        return 'created';
-    }
-    if (files.some((file) => file.status === 'failed')) {
-        return 'failed';
-    }
-    if (files.some((file) => file.status === 'skipped')) {
-        return 'skipped';
-    }
-    return 'unchanged';
-}
-function relativeTo(cwd, filePath) {
-    return path.relative(cwd, filePath) || path.basename(filePath);
-}
-async function planWrites(params) {
-    const { deps, force, mode, projectRoot, selectedPacks, skillRoot, templates } = params;
-    const selected = new Set(selectedPacks);
-    const planned = await Promise.all(templates
-        .filter((entry) => selected.has(entry.pack))
-        .map(async (template) => {
-        const fullPath = path.join(projectRoot, skillRoot, template.relativePath);
-        const exists = deps.existsSync(fullPath);
-        const skill = template.relativePath.split('/')[0] ?? skillDirectoryForPack(template.pack);
-        if (!exists) {
-            return {
-                planned: {
-                    content: template.content,
-                    fullPath,
-                    pack: template.pack,
-                    relativePath: template.relativePath,
-                    skill,
-                    status: 'created',
-                },
-            };
-        }
-        const current = await deps.readFile(fullPath, 'utf8');
-        const managed = containsManagedMarker(current);
-        if (!managed && !force) {
-            return { conflict: fullPath };
-        }
-        if (mode === 'create' && managed) {
-            return {
-                planned: {
-                    content: template.content,
-                    fullPath,
-                    pack: template.pack,
-                    relativePath: template.relativePath,
-                    skill,
-                    status: 'unchanged',
-                },
-            };
-        }
-        return {
-            planned: {
-                content: template.content,
-                fullPath,
-                pack: template.pack,
-                relativePath: template.relativePath,
-                skill,
-                status: 'updated',
-            },
-        };
-    }));
-    const conflicts = planned.flatMap((item) => (item.conflict === undefined ? [] : [item.conflict]));
-    if (conflicts.length > 0) {
-        throw new Error([
-            'Refusing to overwrite existing skill files that are not managed by Agentia.',
-            'Re-run with --force to replace these files:',
-            ...conflicts.map((filePath) => `- ${filePath}`),
-        ].join('\n'));
-    }
-    return planned.flatMap((item) => (item.planned === undefined ? [] : [item.planned]));
-}
-export async function runSetupSkills(options, depsOverrides = {}) {
-    const deps = resolveDeps(depsOverrides);
-    const cwd = options.cwd ?? process.cwd();
-    const selectedPacks = options.packs ?? [...SETUP_SKILL_PACKS];
-    const targets = await resolveSetupSkillTargets({
-        noPrompt: options.noPrompt,
-        prompts: deps.prompts,
-        targets: options.targets ?? (options.target === undefined ? undefined : [options.target]),
-    });
-    const context = await resolveProjectContext(cwd, deps);
-    const templates = await loadTemplates(deps);
-    const planned = (await Promise.all(targets.map((target) => planWrites({
-        deps,
-        force: options.force === true,
-        mode: options.mode,
-        projectRoot: context.projectRoot,
-        selectedPacks,
-        skillRoot: skillRootDirectory(target),
-        templates,
-    })))).flat();
-    await Promise.all(planned
-        .filter((item) => item.status !== 'unchanged')
-        .map(async (item) => {
-        await deps.mkdir(path.dirname(item.fullPath), { recursive: true });
-        const content = item.content.endsWith('\n') ? item.content : `${item.content}\n`;
-        await deps.writeFile(item.fullPath, content, 'utf8');
-    }));
-    const results = targets.map((target) => {
-        const skillRoot = skillRootDirectory(target);
-        const skills = selectedPacks.map((pack) => {
-            const skill = skillDirectoryForPack(pack);
-            const files = planned
-                .filter((item) => item.pack === pack && item.fullPath.startsWith(path.join(context.projectRoot, skillRoot)))
-                .map((item) => ({ path: relativeTo(cwd, item.fullPath), status: item.status }));
-            return { files, pack, path: relativeTo(cwd, path.join(context.projectRoot, skillRoot, skill)), skill, status: summarizeStatus(files) };
-        });
-        options.log?.(`Agentia skills ${options.mode === 'create' ? 'created' : 'updated'} in ${relativeTo(cwd, path.join(context.projectRoot, skillRoot))}.`);
-        for (const entry of skills)
-            options.log?.(`${formatSetupSkillPack(entry.pack)} skill ${entry.status}: ${entry.path}`);
-        return { skillRoot: relativeTo(cwd, path.join(context.projectRoot, skillRoot)), skills, target };
-    });
-    return {
-        cwd,
-        git: context.git,
-        mode: options.mode,
-        projectRoot: context.projectRoot,
-        skillRoot: results.length === 1 ? results[0]?.skillRoot : undefined,
-        skills: results[0]?.skills ?? [],
-        target: results.length === 1 ? results[0]?.target : undefined,
-        targets: results,
-    };
-}
-//# sourceMappingURL=setup-skills.js.map
+import {modules} from './runtime.js';
+const SETUP_SKILL_MANAGED_MARKER = modules["setup-skills.js"]["SETUP_SKILL_MANAGED_MARKER"]
+const SETUP_SKILL_PACKS = modules["setup-skills.js"]["SETUP_SKILL_PACKS"]
+const SETUP_SKILL_TARGETS = modules["setup-skills.js"]["SETUP_SKILL_TARGETS"]
+const formatSetupSkillPack = modules["setup-skills.js"]["formatSetupSkillPack"]
+const isSetupSkillPack = modules["setup-skills.js"]["isSetupSkillPack"]
+const isSetupSkillTarget = modules["setup-skills.js"]["isSetupSkillTarget"]
+const resetSetupSkillsDepsForTests = modules["setup-skills.js"]["resetSetupSkillsDepsForTests"]
+const resolveSelectedSkillPacks = modules["setup-skills.js"]["resolveSelectedSkillPacks"]
+const resolveSetupSkillTarget = modules["setup-skills.js"]["resolveSetupSkillTarget"]
+const resolveSetupSkillTargets = modules["setup-skills.js"]["resolveSetupSkillTargets"]
+const runSetupSkills = modules["setup-skills.js"]["runSetupSkills"]
+const setSetupSkillsDepsForTests = modules["setup-skills.js"]["setSetupSkillsDepsForTests"]
+const skillDirectoryForPack = modules["setup-skills.js"]["skillDirectoryForPack"]
+const skillRootDirectory = modules["setup-skills.js"]["skillRootDirectory"]
+export {SETUP_SKILL_MANAGED_MARKER, SETUP_SKILL_PACKS, SETUP_SKILL_TARGETS, formatSetupSkillPack, isSetupSkillPack, isSetupSkillTarget, resetSetupSkillsDepsForTests, resolveSelectedSkillPacks, resolveSetupSkillTarget, resolveSetupSkillTargets, runSetupSkills, setSetupSkillsDepsForTests, skillDirectoryForPack, skillRootDirectory};