@intra-mart/accel 0.2.0 → 0.3.0-dev.202606150745

package/dist/commands/deploy.js

@@ -0,0 +1,293 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { readFile, stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { detectLocale } from "../utils/locale-detect.js";
+import { formatEpochMillis } from "../utils/date-formatter.js";
+import { readSettings, readSettingsSafe } from "../utils/settings-io.js";
+import { persistCredentials as defaultPersistCredentials, resolveCredentialInputs, } from "../utils/credentials.js";
+import { getMessage } from "../i18n/index.js";
+import { lastFlagValue } from "../utils/args.js";
+import { ensureCredentials as defaultEnsureCredentials, repromptCredentials as defaultRepromptCredentials, resolveCredentialsOrThrow as defaultResolveCredentialsOrThrow, } from "../interactive/credentials-prompts.js";
+import { scanTargets as defaultScanTargets } from "../deploy/target-scanner.js";
+import { selectDeployTarget } from "../deploy/target-selector.js";
+import { verifyCredentialsLoop } from "../interactive/credential-auth.js";
+import { createApiClient as defaultApiClientFactory, isDeployError, } from "../deploy/api-client.js";
+export const toImmFileName = (zipPath) => {
+    const base = basename(zipPath);
+    return base.replace(/\.zip$/i, "") + ".imm";
+};
+const defaultPrompts = {
+    selectStaging: async (stagings, locale) => {
+        const res = await p.select({
+            message: getMessage("deploy.selectStaging", locale),
+            options: stagings.map((s) => ({
+                value: s.stagingId,
+                label: s.description
+                    ? `${s.stagingId} (${s.description})`
+                    : s.stagingId,
+            })),
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    selectZip: async (zips, locale) => {
+        const res = await p.select({
+            message: getMessage("deploy.selectZip", locale),
+            options: zips.map((z) => ({ value: z, label: basename(z) })),
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    description: async (locale) => {
+        const res = await p.text({
+            message: getMessage("deploy.descriptionPrompt", locale),
+            defaultValue: "",
+            initialValue: "",
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    confirm: async (info, locale) => {
+        p.note([
+            `${getMessage("deploy.confirm.endpoint", locale)}: ${info.endpoint}`,
+            `${getMessage("deploy.confirm.stagingId", locale)}: ${info.stagingId}`,
+            `${getMessage("deploy.confirm.sourceFile", locale)}: ${info.sourceFile}`,
+            `${getMessage("deploy.confirm.sentAs", locale)}: ${info.sentAs}`,
+        ].join("\n"));
+        const res = await p.confirm({
+            message: getMessage("deploy.confirm", locale),
+            initialValue: true,
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+};
+const resolveLocale = async (projectDir) => {
+    try {
+        const settings = await readSettings(projectDir);
+        return settings.locale ?? detectLocale();
+    }
+    catch {
+        return detectLocale();
+    }
+};
+const formatDeployError = (err, locale) => {
+    if (err.kind === "network") {
+        return getMessage("deploy.error.network", locale, {
+            message: err.serverMessage ?? "",
+        });
+    }
+    if (err.serverMessage) {
+        return getMessage("deploy.error.server", locale, {
+            message: err.serverMessage,
+        });
+    }
+    switch (err.status) {
+        case 401:
+            return getMessage("deploy.error.unauthorized", locale);
+        case 403:
+            return getMessage("deploy.error.forbidden", locale);
+        case 404:
+            return getMessage("deploy.error.notFound", locale);
+        case 400:
+            return getMessage("deploy.error.badRequest", locale);
+        case 500:
+            return getMessage("deploy.error.serverError", locale);
+        default:
+            return getMessage("deploy.error.unexpectedResponse", locale, {
+                status: String(err.status ?? "?"),
+            });
+    }
+};
+const resolveZipPath = async (opts) => {
+    const { projectDir, locale, nonInteractive, fileArg, scan, selectZip } = opts;
+    if (fileArg && fileArg.length > 0) {
+        const filePath = resolve(projectDir, fileArg);
+        try {
+            const s = await stat(filePath);
+            if (!s.isFile())
+                throw new Error("not a file");
+        }
+        catch {
+            p.log.error(getMessage("deploy.error.fileNotFound", locale, { path: fileArg }));
+            throw new Error("file not found");
+        }
+        return filePath;
+    }
+    const zips = await scan(projectDir);
+    if (zips.length === 0) {
+        p.log.error(getMessage("deploy.error.noTargetZip", locale));
+        throw new Error("no target zip");
+    }
+    const settings = await readSettingsSafe(projectDir);
+    const selection = selectDeployTarget(zips, settings
+        ? { artifactId: settings.artifactId, projectVersion: settings.projectVersion }
+        : null);
+    if ("auto" in selection)
+        return selection.auto;
+    if (nonInteractive) {
+        p.log.error(getMessage("deploy.error.zipNotResolved", locale));
+        throw new Error("zip not resolved");
+    }
+    return selection.candidates.length === 1
+        ? selection.candidates[0]
+        : await selectZip(selection.candidates, locale);
+};
+export const runDeploy = async (deps) => {
+    const { projectDir } = deps;
+    const locale = deps.locale ?? (await resolveLocale(projectDir));
+    const ensureCreds = deps.ensureCredentials ?? defaultEnsureCredentials;
+    const reprompt = deps.repromptCredentials ?? defaultRepromptCredentials;
+    const resolveOrThrow = deps.resolveCredentialsOrThrow ?? defaultResolveCredentialsOrThrow;
+    const persist = deps.persistCredentials ?? defaultPersistCredentials;
+    const scan = deps.scanTargets ?? defaultScanTargets;
+    const apiClientFactory = deps.apiClientFactory ?? defaultApiClientFactory;
+    const prompts = deps.prompts ?? defaultPrompts;
+    const env = deps.env ?? process.env;
+    const nonInteractive = deps.nonInteractive ?? false;
+    const seed = resolveCredentialInputs({ endpoint: deps.endpoint, apiKey: deps.apiKey }, env);
+    const fileArg = deps.file?.trim();
+    const stagingArg = deps.stagingId?.trim();
+    p.intro(getMessage("deploy.intro", locale));
+    const spin = p.spinner();
+    const initialCreds = nonInteractive
+        ? await resolveOrThrow(projectDir, locale, seed)
+        : await ensureCreds(projectDir, locale, seed);
+    const { creds, api } = await verifyCredentialsLoop(projectDir, locale, initialCreds, { dirty: false, interactive: !nonInteractive }, {
+        apiClientFactory,
+        repromptCredentials: reprompt,
+        persistCredentials: persist,
+    });
+    let stagingId;
+    if (stagingArg && stagingArg.length > 0) {
+        stagingId = stagingArg;
+    }
+    else if (nonInteractive) {
+        p.log.error(getMessage("deploy.error.missingStagingId", locale));
+        throw new Error("missing staging id");
+    }
+    else {
+        let stagings;
+        spin.start(getMessage("deploy.progress.fetchingStagings", locale));
+        try {
+            stagings = await api.listStagings();
+            spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+        }
+        catch (err) {
+            spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+            throw logAndRethrow(err, locale);
+        }
+        if (stagings.length === 0) {
+            p.log.error(getMessage("deploy.error.noStagings", locale));
+            throw new Error("no stagings");
+        }
+        stagingId = await prompts.selectStaging(stagings, locale);
+    }
+    const zipPath = await resolveZipPath({
+        projectDir,
+        locale,
+        nonInteractive,
+        fileArg,
+        scan,
+        selectZip: prompts.selectZip,
+    });
+    const description = (deps.description !== undefined
+        ? deps.description
+        : nonInteractive
+            ? ""
+            : await prompts.description(locale)).trim();
+    const immName = toImmFileName(zipPath);
+    if (!nonInteractive) {
+        const confirmed = await prompts.confirm({
+            endpoint: creds.endpoint,
+            stagingId,
+            sourceFile: basename(zipPath),
+            sentAs: immName,
+        }, locale);
+        if (!confirmed) {
+            p.log.info(getMessage("deploy.cancelled", locale));
+            return;
+        }
+    }
+    const bytes = await readFile(zipPath);
+    spin.start(getMessage("deploy.progress.deploying", locale));
+    let result;
+    try {
+        result = await api.createDeployment(stagingId, bytes, immName, description.length > 0 ? description : undefined);
+    }
+    catch (err) {
+        spin.stop(getMessage("deploy.progress.deploying", locale));
+        throw logAndRethrow(err, locale);
+    }
+    spin.stop(getMessage("deploy.progress.deploying", locale));
+    p.note([
+        `${getMessage("deploy.result.deployId", locale)}: ${result.deployId}`,
+        `${getMessage("deploy.result.stagingId", locale)}: ${result.stagingId}`,
+        `${getMessage("deploy.result.status", locale)}: ${result.status}`,
+        `${getMessage("deploy.result.createDate", locale)}: ${formatEpochMillis(result.createDate, locale)}`,
+    ].join("\n"));
+    p.outro(getMessage("deploy.success", locale));
+};
+const logAndRethrow = (err, locale) => {
+    if (isDeployError(err)) {
+        p.log.error(formatDeployError(err, locale));
+    }
+    else {
+        p.log.error(err instanceof Error ? err.message : String(err));
+    }
+    return err;
+};
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy build artifacts to an iAP staging environment",
+    },
+    args: {
+        endpoint: {
+            type: "string",
+            description: "iAP base URL (or set ACCEL_ENDPOINT)",
+        },
+        "api-key": {
+            type: "string",
+            description: "OAuth Bearer token. Prefer the ACCEL_API_KEY env var (argv leaks to process listings / CI logs)",
+        },
+        "staging-id": {
+            type: "string",
+            description: "Target staging ID (required in non-interactive mode)",
+        },
+        file: {
+            type: "string",
+            description: "Path to the zip to deploy (not restricted to ./target/)",
+        },
+        description: {
+            type: "string",
+            description: "Deployment description",
+        },
+        "non-interactive": {
+            type: "boolean",
+            description: "Non-interactive mode (no prompts; exits non-zero on failure)",
+            default: false,
+        },
+    },
+    run: async ({ args }) => {
+        try {
+            await runDeploy({
+                projectDir: process.cwd(),
+                nonInteractive: args["non-interactive"],
+                endpoint: lastFlagValue(args.endpoint),
+                apiKey: lastFlagValue(args["api-key"]),
+                stagingId: lastFlagValue(args["staging-id"]),
+                file: lastFlagValue(args.file),
+                description: lastFlagValue(args.description),
+            });
+        }
+        catch {
+            process.exit(1);
+        }
+    },
+});

package/dist/commands/init.d.ts

@@ -16,6 +16,10 @@ export declare const initCommand: import("citty").CommandDef<{
         type: "string";
         description: string;
     };
+    feature: {
+        type: "string";
+        description: string;
+    };
     group: {
         type: "string";
         description: string;
@@ -67,11 +71,19 @@ export declare const initCommand: import("citty").CommandDef<{
         description: string;
         default: false;
     };
+    "asset-server-url": {
+        type: "string";
+        description: string;
+    };
+    "asset-ref": {
+        type: "string";
+        description: string;
+    };
     "asset-source": {
         type: "string";
         description: string;
     };
-    "asset-server-url": {
+    "debug-server-url": {
         type: "string";
         description: string;
     };

package/dist/commands/init.js

@@ -3,12 +3,12 @@ import * as p from "@clack/prompts";
 import { mkdir, stat } from "node:fs/promises";
 import { execSync } from "node:child_process";
 import { resolve } from "node:path";
-import { CLI_VERSION } from "../core/constants.js";
+import { CLI_VERSION, DEFAULT_ASSET_REPO_URL, DEFAULT_ASSET_REF, } from "../core/constants.js";
 import { runPrompts } from "../interactive/prompts.js";
 import { deployAssets } from "../asset/deployer.js";
 import { createLocalAssetProvider } from "../asset/local-provider.js";
 import { createFileAssetProvider } from "../asset/file-provider.js";
-import { defaultAssetSourcePath } from "../asset/default-source.js";
+import { createGitHubAssetProvider } from "../asset/github-provider.js";
 import { getMessage } from "../i18n/index.js";
 import { detectLocale } from "../utils/locale-detect.js";
 import { commandExists } from "../utils/command-exists.js";
@@ -32,11 +32,15 @@ export const initCommand = defineCommand({
         },
         "accelplatform-version": {
             type: "string",
-            description: "iAP version (e.g., 2026-Spring)",
+            description: "iAP version (e.g., 2026-spring)",
         },
         module: {
             type: "string",
-            description: "Modules to use (comma-separated)",
+            description: "Modules to use (comma-separated artifactIds, e.g., im_workflow)",
+        },
+        feature: {
+            type: "string",
+            description: "Features to use (comma-separated function ids, e.g., jssp)",
         },
         group: {
             type: "string",
@@ -89,13 +93,21 @@ export const initCommand = defineCommand({
             description: "Non-interactive mode",
             default: false,
         },
+        "asset-server-url": {
+            type: "string",
+            description: "GitHub repository URL to fetch assets from (overrides the default repository)",
+        },
+        "asset-ref": {
+            type: "string",
+            description: "Git ref (branch/tag/commit) to fetch from the GitHub asset repository. Default: master",
+        },
         "asset-source": {
             type: "string",
-            description: "Local asset source path (tar archive or extracted directory). Defaults to the bundled assets/assets.tar.gz.",
+            description: "(debug) Local asset source path (tar archive or extracted directory)",
         },
-        "asset-server-url": {
+        "debug-server-url": {
             type: "string",
-            description: "Asset server URL (takes precedence over --asset-source when explicitly set)",
+            description: "(debug) Local asset server URL serving GET /archive",
         },
     },
     run: async ({ args }) => {
@@ -105,6 +117,10 @@ export const initCommand = defineCommand({
         const modules = moduleArg
             ? moduleArg.split(",").map((m) => m.trim())
             : undefined;
+        const featureArg = args.feature;
+        const features = featureArg
+            ? featureArg.split(",").map((f) => f.trim())
+            : undefined;
         const agentArg = args.agent;
         const promptOpts = {
             name: projectName,
@@ -112,6 +128,7 @@ export const initCommand = defineCommand({
             jugglingProject: args["juggling-project"],
             accelplatformVersion: args["accelplatform-version"],
             module: modules,
+            feature: features,
             group: args.group,
             projectVersion: args["project-version"],
             description: args.description,
@@ -153,6 +170,7 @@ export const initCommand = defineCommand({
             description: resolved.description,
             accelplatformVersion: resolved.accelplatformVersion,
             modules: resolved.modules,
+            features: resolved.features,
             database: resolved.database,
             agents: resolved.agents,
             javascript: resolved.javascript,
@@ -165,11 +183,14 @@ export const initCommand = defineCommand({
         if (isInteractive) {
             printSummary(settings, projectDir, locale);
         }
-        const serverUrl = args["asset-server-url"];
-        const assetSource = args["asset-source"] ?? defaultAssetSourcePath();
-        const provider = serverUrl
-            ? createLocalAssetProvider(serverUrl)
-            : createFileAssetProvider(assetSource);
+        const assetSource = args["asset-source"];
+        const debugServerUrl = args["debug-server-url"];
+        const provider = assetSource
+            ? createFileAssetProvider(assetSource)
+            : debugServerUrl
+                ? createLocalAssetProvider(debugServerUrl)
+                : createGitHubAssetProvider(args["asset-server-url"] ??
+                    DEFAULT_ASSET_REPO_URL, args["asset-ref"] ?? DEFAULT_ASSET_REF);
         await deployAssets({
             projectDir,
             settings,

package/dist/commands/login.d.ts

@@ -0,0 +1,31 @@
+import type { AccelCredentials } from "../core/types.js";
+import { type ApiClient } from "../deploy/api-client.js";
+export type RunLoginDeps = {
+    projectDir: string;
+    locale?: string;
+    nonInteractive?: boolean;
+    endpoint?: string;
+    apiKey?: string;
+    env?: Record<string, string | undefined>;
+    readCredentials?: (projectDir: string) => Promise<Partial<AccelCredentials>>;
+    repromptCredentials?: (current: AccelCredentials, locale: string, seed?: Partial<AccelCredentials>) => Promise<AccelCredentials>;
+    resolveCredentialsOrThrow?: (projectDir: string, locale: string, seed: Partial<AccelCredentials>) => Promise<AccelCredentials>;
+    persistCredentials?: (projectDir: string, creds: AccelCredentials) => Promise<void>;
+    apiClientFactory?: (endpoint: string, apiKey: string) => ApiClient;
+};
+export declare const runLogin: (deps: RunLoginDeps) => Promise<void>;
+export declare const loginCommand: import("citty").CommandDef<{
+    endpoint: {
+        type: "string";
+        description: string;
+    };
+    "api-key": {
+        type: "string";
+        description: string;
+    };
+    "non-interactive": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;

package/dist/commands/login.js

@@ -0,0 +1,75 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { detectLocale } from "../utils/locale-detect.js";
+import { readSettingsSafe } from "../utils/settings-io.js";
+import { readCredentials as defaultReadCredentials, persistCredentials as defaultPersistCredentials, resolveCredentialInputs, } from "../utils/credentials.js";
+import { repromptCredentials as defaultRepromptCredentials, resolveCredentialsOrThrow as defaultResolveCredentialsOrThrow, } from "../interactive/credentials-prompts.js";
+import { verifyCredentialsLoop } from "../interactive/credential-auth.js";
+import { createApiClient as defaultApiClientFactory, } from "../deploy/api-client.js";
+import { getMessage } from "../i18n/index.js";
+import { lastFlagValue } from "../utils/args.js";
+const resolveLocale = async (projectDir) => {
+    const settings = await readSettingsSafe(projectDir);
+    return settings?.locale ?? detectLocale();
+};
+export const runLogin = async (deps) => {
+    const { projectDir } = deps;
+    const locale = deps.locale ?? (await resolveLocale(projectDir));
+    const read = deps.readCredentials ?? defaultReadCredentials;
+    const reprompt = deps.repromptCredentials ?? defaultRepromptCredentials;
+    const resolveOrThrow = deps.resolveCredentialsOrThrow ?? defaultResolveCredentialsOrThrow;
+    const persist = deps.persistCredentials ?? defaultPersistCredentials;
+    const apiClientFactory = deps.apiClientFactory ?? defaultApiClientFactory;
+    const env = deps.env ?? process.env;
+    const seed = resolveCredentialInputs({ endpoint: deps.endpoint, apiKey: deps.apiKey }, env);
+    p.intro(getMessage("login.intro", locale));
+    let initial;
+    if (deps.nonInteractive) {
+        initial = await resolveOrThrow(projectDir, locale, seed);
+    }
+    else {
+        const existing = await read(projectDir);
+        initial = await reprompt({ endpoint: existing.endpoint ?? "", apiKey: existing.apiKey ?? "" }, locale, seed);
+    }
+    const { creds } = await verifyCredentialsLoop(projectDir, locale, initial, { dirty: true, interactive: !deps.nonInteractive }, {
+        apiClientFactory,
+        repromptCredentials: reprompt,
+        persistCredentials: persist,
+    });
+    p.log.success(`endpoint: ${creds.endpoint}`);
+    p.outro(getMessage("login.complete", locale));
+};
+export const loginCommand = defineCommand({
+    meta: {
+        name: "login",
+        description: "Configure and verify iAP connection credentials",
+    },
+    args: {
+        endpoint: {
+            type: "string",
+            description: "iAP base URL (or set ACCEL_ENDPOINT)",
+        },
+        "api-key": {
+            type: "string",
+            description: "OAuth Bearer token. Prefer the ACCEL_API_KEY env var (argv leaks to process listings / CI logs)",
+        },
+        "non-interactive": {
+            type: "boolean",
+            description: "Non-interactive mode (no prompts; exits non-zero on failure)",
+            default: false,
+        },
+    },
+    run: async ({ args }) => {
+        try {
+            await runLogin({
+                projectDir: process.cwd(),
+                nonInteractive: args["non-interactive"],
+                endpoint: lastFlagValue(args.endpoint),
+                apiKey: lastFlagValue(args["api-key"]),
+            });
+        }
+        catch {
+            process.exit(1);
+        }
+    },
+});

package/dist/core/catalog.d.ts

@@ -0,0 +1,11 @@
+import type { Release, ModuleEntry, FunctionEntry, Labels } from "@intra-mart/catalog";
+import type { AccelplatformVersion, ModuleContextItem, FeatureContextItem } from "./types.js";
+export type { Release, ModuleEntry, FunctionEntry, Labels };
+export declare const getReleases: () => readonly Release[];
+export declare const findReleaseById: (id: string) => Release | undefined;
+export declare const findReleaseBySemver: (semver: string) => Release | undefined;
+export declare const resolveAccelplatformVersion: (id: string) => AccelplatformVersion;
+export declare const resolveLabel: (labels: Labels, locale: string) => string;
+export declare const findModuleByCatalogId: (release: Release, id: string) => ModuleEntry | undefined;
+export declare const toModuleContextItems: (release: Release, artifactIds: string[], locale: string) => ModuleContextItem[];
+export declare const toFeatureContextItems: (release: Release, functionIds: string[], locale: string) => FeatureContextItem[];

package/dist/core/catalog.js

@@ -0,0 +1,40 @@
+import { catalog } from "@intra-mart/catalog";
+export const getReleases = () => catalog;
+export const findReleaseById = (id) => catalog.find((r) => r.id === id);
+export const findReleaseBySemver = (semver) => catalog.find((r) => r.version === semver);
+export const resolveAccelplatformVersion = (id) => {
+    const release = findReleaseById(id);
+    if (!release) {
+        throw new Error(`Unknown iAP release id: ${id}`);
+    }
+    return { label: release.id, semver: release.version };
+};
+export const resolveLabel = (labels, locale) => labels[locale] ?? labels.en;
+export const findModuleByCatalogId = (release, id) => release.modules.find((m) => m.id === id);
+export const toModuleContextItems = (release, artifactIds, locale) => artifactIds.flatMap((artifactId) => {
+    const entry = release.modules.find((m) => m.artifactId === artifactId);
+    if (!entry)
+        return [];
+    return [
+        {
+            id: entry.id,
+            groupId: entry.groupId,
+            artifactId: entry.artifactId,
+            version: entry.version,
+            name: entry.name,
+            label: resolveLabel(entry.labels, locale),
+        },
+    ];
+});
+export const toFeatureContextItems = (release, functionIds, locale) => functionIds.flatMap((functionId) => {
+    const entry = release.functions.find((f) => f.id === functionId);
+    if (!entry)
+        return [];
+    return [
+        {
+            id: entry.id,
+            name: entry.name,
+            label: resolveLabel(entry.labels, locale),
+        },
+    ];
+});

package/dist/core/condition-evaluator.js

@@ -1,5 +1,5 @@
 import { satisfies } from "semver";
-import { isAndCondition, isOrCondition, isVersionCondition, isModuleCondition, isLocaleCondition, isAgentCondition, isPackageManagerCondition, isJavascriptCondition, } from "./types.js";
+import { isAndCondition, isOrCondition, isAccelplatformVersionCondition, isModuleCondition, isFeatureCondition, isLocaleCondition, isAgentCondition, isPackageManagerCondition, isJavascriptCondition, } from "./types.js";
 export const evaluateCondition = (condition, context) => {
     if (condition === undefined) {
         return true;
@@ -10,12 +10,15 @@ export const evaluateCondition = (condition, context) => {
     if (isOrCondition(condition)) {
         return condition.or.some((c) => evaluateCondition(c, context));
     }
-    if (isVersionCondition(condition)) {
-        return satisfies(context.version, condition.version);
+    if (isAccelplatformVersionCondition(condition)) {
+        return satisfies(context.accelplatformVersion.semver, condition.accelplatformVersion);
     }
     if (isModuleCondition(condition)) {
         return context.modules.includes(condition.module);
     }
+    if (isFeatureCondition(condition)) {
+        return context.features.includes(condition.feature);
+    }
     if (isLocaleCondition(condition)) {
         return context.locale === condition.locale;
     }

package/dist/core/constants.d.ts

@@ -4,10 +4,10 @@ export declare const DATABASE_OPTIONS: readonly ["postgresql", "oracle", "sqlser
 export type DatabaseOption = (typeof DATABASE_OPTIONS)[number];
 export declare const AGENT_OPTIONS: readonly ["claude-code", "github-copilot"];
 export type AgentOption = (typeof AGENT_OPTIONS)[number];
-export declare const MODULE_OPTIONS: readonly ["workflow", "bpm", "copilot", "imbox", "pdfd", "kaiden"];
-export type ModuleOption = (typeof MODULE_OPTIONS)[number];
 export declare const LOCALE_OPTIONS: readonly ["ja", "en", "zh_CN"];
 export type LocaleOption = (typeof LOCALE_OPTIONS)[number];
 export declare const PACKAGE_MANAGER_OPTIONS: readonly ["bun", "npm", "yarn", "pnpm"];
 export type PackageManagerOption = (typeof PACKAGE_MANAGER_OPTIONS)[number];
+export declare const DEFAULT_ASSET_REPO_URL = "https://github.com/accelplatform/skills";
+export declare const DEFAULT_ASSET_REF = "experiment";
 export declare const DEFAULT_SETTINGS: Omit<AccelSettings, "cliVersion" | "createdAt" | "deployedAssets">;

package/dist/core/constants.js

@@ -1,14 +1,6 @@
 export const CLI_VERSION = "0.1.0";
 export const DATABASE_OPTIONS = ["postgresql", "oracle", "sqlserver"];
 export const AGENT_OPTIONS = ["claude-code", "github-copilot"];
-export const MODULE_OPTIONS = [
-    "workflow",
-    "bpm",
-    "copilot",
-    "imbox",
-    "pdfd",
-    "kaiden",
-];
 export const LOCALE_OPTIONS = ["ja", "en", "zh_CN"];
 export const PACKAGE_MANAGER_OPTIONS = [
     "bun",
@@ -16,14 +8,17 @@ export const PACKAGE_MANAGER_OPTIONS = [
     "yarn",
     "pnpm",
 ];
+export const DEFAULT_ASSET_REPO_URL = "https://github.com/accelplatform/skills";
+export const DEFAULT_ASSET_REF = "experiment";
 export const DEFAULT_SETTINGS = {
     name: "my-accel-project",
     artifactId: "",
     group: "com.example",
     projectVersion: "0.1.0",
     description: "",
-    accelplatformVersion: "2025-Autumn",
+    accelplatformVersion: { label: "2026-spring", semver: "8.0.39" },
     modules: [],
+    features: [],
     database: "postgresql",
     agents: ["claude-code", "github-copilot"],
     javascript: false,

package/dist/core/eval-context.d.ts

@@ -0,0 +1,3 @@
+import type { AccelSettings, EvalContext } from "./types.js";
+export declare const buildEvalContext: (settings: AccelSettings) => EvalContext;
+export declare const emptyEvalContext: (overrides?: Partial<EvalContext>) => EvalContext;