@intra-mart/accel 0.1.0-dev-20260420

package/dist/commands/detach.js

@@ -0,0 +1,74 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { readFile, rm, unlink, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { readSettings, readHashsum } from "../utils/settings-io.js";
+import { computeSha1 } from "../utils/hash.js";
+import { getMessage } from "../i18n/index.js";
+import { detectLocale } from "../utils/locale-detect.js";
+export const detachCommand = defineCommand({
+    meta: {
+        name: "detach",
+        description: "Detach Accel CLI from this project",
+    },
+    args: {},
+    run: async () => {
+        const projectDir = process.cwd();
+        const locale = detectLocale();
+        // Check .accel exists
+        try {
+            await stat(join(projectDir, ".accel"));
+        }
+        catch {
+            p.log.error(getMessage("error.accelNotFound", locale));
+            process.exit(1);
+        }
+        const settings = await readSettings(projectDir);
+        const effectiveLocale = settings.locale ?? locale;
+        const hashEntries = await readHashsum(projectDir);
+        p.intro("Accel CLI - detach");
+        const confirmed = await p.confirm({
+            message: getMessage("detach.confirm", effectiveLocale),
+            initialValue: false,
+        });
+        if (p.isCancel(confirmed) || !confirmed) {
+            p.log.info(getMessage("detach.cancelled", effectiveLocale));
+            return;
+        }
+        let skipped = 0;
+        let deleted = 0;
+        for (const entry of hashEntries) {
+            const filePath = join(projectDir, entry.filePath);
+            try {
+                const content = await readFile(filePath, "utf-8");
+                const currentHash = computeSha1(content);
+                if (currentHash === entry.sha1) {
+                    await unlink(filePath);
+                    p.log.success(getMessage("detach.deleted", effectiveLocale, {
+                        path: entry.filePath,
+                    }));
+                    deleted++;
+                }
+                else {
+                    p.log.warning(getMessage("detach.skipped", effectiveLocale, {
+                        path: entry.filePath,
+                    }));
+                    skipped++;
+                }
+            }
+            catch {
+                // File doesn't exist — already removed
+            }
+        }
+        // Delete .accel directory
+        await rm(join(projectDir, ".accel"), { recursive: true, force: true });
+        if (skipped > 0) {
+            p.outro(getMessage("detach.complete", effectiveLocale, {
+                skipped: String(skipped),
+            }));
+        }
+        else {
+            p.outro(getMessage("detach.completeAll", effectiveLocale));
+        }
+    },
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,70 @@
+export declare const initCommand: import("citty").CommandDef<{
+    name: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    "juggling-project": {
+        type: "string";
+        description: string;
+    };
+    "accelplatform-version": {
+        type: "string";
+        description: string;
+    };
+    module: {
+        type: "string";
+        description: string;
+    };
+    group: {
+        type: "string";
+        description: string;
+    };
+    "project-version": {
+        type: "string";
+        description: string;
+    };
+    description: {
+        type: "string";
+        description: string;
+    };
+    database: {
+        type: "string";
+        description: string;
+    };
+    javascript: {
+        type: "boolean";
+        description: string;
+    };
+    agent: {
+        type: "string";
+        description: string;
+    };
+    locale: {
+        type: "string";
+        description: string;
+    };
+    "git-init": {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    "skip-install": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "non-interactive": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "asset-source": {
+        type: "string";
+        description: string;
+    };
+    "asset-server-url": {
+        type: "string";
+        description: string;
+    };
+}>;

package/dist/commands/init.js

@@ -0,0 +1,178 @@
+import { defineCommand } from "citty";
+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 { 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 { getMessage } from "../i18n/index.js";
+import { detectLocale } from "../utils/locale-detect.js";
+export const initCommand = defineCommand({
+    meta: {
+        name: "init",
+        description: "Initialize a new Accel project",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Project name (directory name)",
+            required: false,
+        },
+        "juggling-project": {
+            type: "string",
+            description: "Path to IM-Juggling project",
+        },
+        "accelplatform-version": {
+            type: "string",
+            description: "iAP version (e.g., 2026-Spring)",
+        },
+        module: {
+            type: "string",
+            description: "Modules to use (comma-separated)",
+        },
+        group: {
+            type: "string",
+            description: "Group name",
+        },
+        "project-version": {
+            type: "string",
+            description: "Project version",
+        },
+        description: {
+            type: "string",
+            description: "Project description",
+        },
+        database: {
+            type: "string",
+            description: "Database type",
+        },
+        javascript: {
+            type: "boolean",
+            description: "Use JavaScript",
+        },
+        agent: {
+            type: "string",
+            description: "Agent type",
+        },
+        locale: {
+            type: "string",
+            description: "Locale (ja, en, zh_CN)",
+        },
+        "git-init": {
+            type: "boolean",
+            description: "Initialize git repository (use --no-git-init to disable)",
+            default: true,
+        },
+        "skip-install": {
+            type: "boolean",
+            description: "Skip dependency installation",
+            default: false,
+        },
+        "non-interactive": {
+            type: "boolean",
+            description: "Non-interactive mode",
+            default: false,
+        },
+        "asset-source": {
+            type: "string",
+            description: "Local asset source path (tar archive or extracted directory). Defaults to the bundled assets/assets.tar.gz.",
+        },
+        "asset-server-url": {
+            type: "string",
+            description: "Asset server URL (takes precedence over --asset-source when explicitly set)",
+        },
+    },
+    run: async ({ args }) => {
+        const locale = args.locale ?? detectLocale();
+        const projectName = args.name;
+        // Parse module option (comma-separated or repeated)
+        const moduleArg = args.module;
+        const modules = moduleArg
+            ? moduleArg.split(",").map((m) => m.trim())
+            : undefined;
+        const agentArg = args.agent;
+        const promptOpts = {
+            name: projectName,
+            jugglingProject: args["juggling-project"],
+            accelplatformVersion: args["accelplatform-version"],
+            module: modules,
+            group: args.group,
+            projectVersion: args["project-version"],
+            description: args.description,
+            database: args.database,
+            javascript: args.javascript,
+            agent: agentArg
+                ? agentArg.split(",").map((a) => a.trim())
+                : undefined,
+            locale,
+            withGit: args["git-init"],
+            noInteraction: args["non-interactive"],
+            isInit: true,
+        };
+        let resolved;
+        try {
+            resolved = await runPrompts(promptOpts);
+        }
+        catch (err) {
+            p.log.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        // Resolve final project directory from interactive result and create it
+        const projectDir = resolve(process.cwd(), resolved.name);
+        try {
+            await stat(projectDir);
+            p.log.error(getMessage("error.directoryExists", locale, { path: projectDir }));
+            process.exit(1);
+        }
+        catch {
+            // Directory doesn't exist — good
+        }
+        await mkdir(projectDir, { recursive: true });
+        // Build settings
+        const settings = {
+            cliVersion: CLI_VERSION,
+            createdAt: new Date().toISOString(),
+            name: resolved.name,
+            group: resolved.group,
+            projectVersion: resolved.projectVersion,
+            description: resolved.description,
+            accelplatformVersion: resolved.accelplatformVersion,
+            modules: resolved.modules,
+            database: resolved.database,
+            agents: resolved.agents,
+            javascript: resolved.javascript,
+            locale: resolved.locale,
+            jugglingProject: resolved.jugglingProject,
+            deployedAssets: {},
+        };
+        // Deploy assets
+        const serverUrl = args["asset-server-url"];
+        const assetSource = args["asset-source"] ?? defaultAssetSourcePath();
+        const provider = serverUrl
+            ? createLocalAssetProvider(serverUrl)
+            : createFileAssetProvider(assetSource);
+        p.log.info(getMessage("progress.deploying", locale));
+        await deployAssets({
+            projectDir,
+            settings,
+            provider,
+            noInstall: args["skip-install"],
+        });
+        // Git init
+        if (resolved.withGit) {
+            try {
+                execSync("which git", { stdio: "pipe" });
+                p.log.info(getMessage("progress.gitInit", locale));
+                execSync("git init", { cwd: projectDir, stdio: "pipe" });
+            }
+            catch {
+                p.log.warning(getMessage("warning.gitNotFound", locale));
+            }
+        }
+        p.log.success(getMessage("progress.complete", locale));
+    },
+});

package/dist/core/condition-evaluator.d.ts

@@ -0,0 +1,2 @@
+import type { Condition, EvalContext } from "./types.js";
+export declare const evaluateCondition: (condition: Condition | undefined, context: EvalContext) => boolean;

package/dist/core/condition-evaluator.js

@@ -0,0 +1,26 @@
+import { satisfies } from "semver";
+import { isAndCondition, isOrCondition, isVersionCondition, isModuleCondition, isLocaleCondition, isAgentCondition, } from "./types.js";
+export const evaluateCondition = (condition, context) => {
+    if (condition === undefined) {
+        return true;
+    }
+    if (isAndCondition(condition)) {
+        return condition.and.every((c) => evaluateCondition(c, context));
+    }
+    if (isOrCondition(condition)) {
+        return condition.or.some((c) => evaluateCondition(c, context));
+    }
+    if (isVersionCondition(condition)) {
+        return satisfies(context.version, condition.version);
+    }
+    if (isModuleCondition(condition)) {
+        return context.modules.includes(condition.module);
+    }
+    if (isLocaleCondition(condition)) {
+        return context.locale === condition.locale;
+    }
+    if (isAgentCondition(condition)) {
+        return context.agents.includes(condition.agent);
+    }
+    return false;
+};

package/dist/core/constants.d.ts

@@ -0,0 +1,11 @@
+import type { AccelSettings } from "./types.js";
+export declare const CLI_VERSION = "0.1.0";
+export declare const DATABASE_OPTIONS: readonly ["postgresql", "oracle", "sqlserver"];
+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 DEFAULT_SETTINGS: Omit<AccelSettings, "cliVersion" | "createdAt" | "deployedAssets">;

package/dist/core/constants.js

@@ -0,0 +1,30 @@
+export const CLI_VERSION = "0.1.0";
+// --- Database options ---
+export const DATABASE_OPTIONS = ["postgresql", "oracle", "sqlserver"];
+// --- Agent options ---
+export const AGENT_OPTIONS = ["claude-code", "github-copilot"];
+// --- Module options ---
+export const MODULE_OPTIONS = [
+    "workflow",
+    "bpm",
+    "copilot",
+    "imbox",
+    "pdfd",
+    "kaiden",
+];
+// --- Locale options ---
+export const LOCALE_OPTIONS = ["ja", "en", "zh_CN"];
+// --- Default settings ---
+export const DEFAULT_SETTINGS = {
+    name: "my-accel-project",
+    group: "my-group",
+    projectVersion: "0.1.0",
+    description: "",
+    accelplatformVersion: "2026-Spring",
+    modules: [],
+    database: "postgresql",
+    agents: ["claude-code", "github-copilot"],
+    javascript: false,
+    locale: "ja",
+    jugglingProject: null,
+};

package/dist/core/module-map.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mapping from CLI module names to juggling.im XML module IDs.
+ * This map will be extended as more modules are added.
+ */
+export declare const MODULE_ID_MAP: Record<string, string>;
+export declare const xmlIdToModuleName: (xmlId: string) => string | undefined;
+export declare const moduleNameToXmlId: (moduleName: string) => string | undefined;

package/dist/core/module-map.js

@@ -0,0 +1,12 @@
+/**
+ * Mapping from CLI module names to juggling.im XML module IDs.
+ * This map will be extended as more modules are added.
+ */
+export const MODULE_ID_MAP = {
+    workflow: "jp.co.intra_mart.im_workflow",
+    copilot: "jp.co.intra_mart.im_copilot",
+    // TODO: Add mappings for bpm, imbox, pdfd, kaiden
+};
+const reverseMap = new Map(Object.entries(MODULE_ID_MAP).map(([key, value]) => [value, key]));
+export const xmlIdToModuleName = (xmlId) => reverseMap.get(xmlId);
+export const moduleNameToXmlId = (moduleName) => MODULE_ID_MAP[moduleName];

package/dist/core/types.d.ts

@@ -0,0 +1,100 @@
+export type AndCondition = {
+    and: Condition[];
+};
+export type OrCondition = {
+    or: Condition[];
+};
+export type VersionCondition = {
+    version: string;
+};
+export type ModuleCondition = {
+    module: string;
+};
+export type LocaleCondition = {
+    locale: string;
+};
+export type AgentCondition = {
+    agent: string;
+};
+export type LeafCondition = VersionCondition | ModuleCondition | LocaleCondition | AgentCondition;
+export type Condition = AndCondition | OrCondition | LeafCondition;
+export type TextReplacement = {
+    type: "text";
+    target: string;
+    values: {
+        condition: Condition;
+        value: string;
+    }[];
+};
+export type SectionReplacement = {
+    type: "section";
+    heading: string;
+    condition: Condition;
+};
+export type RegexReplacement = {
+    type: "regex";
+    pattern: string;
+    replacement: string;
+    condition: Condition;
+};
+export type Replacement = TextReplacement | SectionReplacement | RegexReplacement;
+export type RenameRule = {
+    condition: Condition;
+    from: string;
+    to: string;
+};
+export type MetaJson = {
+    version: string;
+    type: "file" | "directory";
+    conditions?: Condition;
+    rename?: RenameRule[];
+    replacements?: Replacement[];
+};
+export type IapVersion = {
+    semver: string;
+    label: string;
+    codename: string;
+};
+export type AccelSettings = {
+    cliVersion: string;
+    createdAt: string;
+    name: string;
+    group: string;
+    projectVersion: string;
+    description: string;
+    accelplatformVersion: string;
+    modules: string[];
+    database: string;
+    agents: string[];
+    javascript: boolean;
+    locale: string;
+    jugglingProject: string | null;
+    deployedAssets: Record<string, string>;
+};
+export type HashsumEntry = {
+    filePath: string;
+    version: string;
+    sha1: string;
+};
+export type AssetProvider = {
+    fetch: () => Promise<string>;
+    cleanup: () => Promise<void>;
+};
+export type EvalContext = {
+    version: string;
+    modules: string[];
+    locale: string;
+    agents: string[];
+    name: string;
+    group: string;
+    description: string;
+    accelplatformVersion: string;
+    database: string;
+    projectVersion: string;
+};
+export declare const isAndCondition: (c: Condition) => c is AndCondition;
+export declare const isOrCondition: (c: Condition) => c is OrCondition;
+export declare const isVersionCondition: (c: Condition) => c is VersionCondition;
+export declare const isModuleCondition: (c: Condition) => c is ModuleCondition;
+export declare const isLocaleCondition: (c: Condition) => c is LocaleCondition;
+export declare const isAgentCondition: (c: Condition) => c is AgentCondition;

package/dist/core/types.js

@@ -0,0 +1,8 @@
+// --- Condition types ---
+// --- Condition type guards ---
+export const isAndCondition = (c) => "and" in c;
+export const isOrCondition = (c) => "or" in c;
+export const isVersionCondition = (c) => "version" in c && !("and" in c) && !("or" in c);
+export const isModuleCondition = (c) => "module" in c;
+export const isLocaleCondition = (c) => "locale" in c;
+export const isAgentCondition = (c) => "agent" in c;

package/dist/core/variable-interpolator.d.ts

@@ -0,0 +1,10 @@
+import type { EvalContext } from "./types.js";
+/**
+ * Interpolate {{$variable}} placeholders in a string using EvalContext values.
+ *
+ * - Known variables are replaced with their EvalContext value (empty string if value is "").
+ * - Unknown variables (not in the allowlist) are left unchanged.
+ * - Array-type fields (modules, agents) are not available as variables.
+ * - No recursive expansion: if a variable's value contains {{$...}}, it is NOT re-expanded.
+ */
+export declare const interpolateVariables: (template: string, context: EvalContext) => string;

package/dist/core/variable-interpolator.js

@@ -0,0 +1,37 @@
+/**
+ * Allowlist of variable names that can be interpolated.
+ * Maps {{$varName}} to the corresponding EvalContext field.
+ * Array fields (modules, agents) are deliberately excluded.
+ */
+const VARIABLE_MAP = new Map([
+    ["name", "name"],
+    ["group", "group"],
+    ["description", "description"],
+    ["version", "version"],
+    ["accelplatformVersion", "accelplatformVersion"],
+    ["locale", "locale"],
+    ["database", "database"],
+    ["projectVersion", "projectVersion"],
+]);
+const INTERPOLATION_PATTERN = /\{\{\$(\w+)\}\}/g;
+/**
+ * Interpolate {{$variable}} placeholders in a string using EvalContext values.
+ *
+ * - Known variables are replaced with their EvalContext value (empty string if value is "").
+ * - Unknown variables (not in the allowlist) are left unchanged.
+ * - Array-type fields (modules, agents) are not available as variables.
+ * - No recursive expansion: if a variable's value contains {{$...}}, it is NOT re-expanded.
+ */
+export const interpolateVariables = (template, context) => {
+    return template.replace(INTERPOLATION_PATTERN, (match, varName) => {
+        const field = VARIABLE_MAP.get(varName);
+        if (field === undefined) {
+            return match;
+        }
+        const value = context[field];
+        if (typeof value !== "string") {
+            return match;
+        }
+        return value;
+    });
+};

package/dist/core/version-map.d.ts

@@ -0,0 +1,7 @@
+import type { IapVersion } from "./types.js";
+export declare const IAP_VERSIONS: readonly IapVersion[];
+export declare const SELECTABLE_VERSIONS: readonly IapVersion[];
+export declare const labelToSemver: (label: string) => string;
+export declare const semverToLabel: (semver: string) => string;
+export declare const findByLabel: (label: string) => IapVersion | undefined;
+export declare const findBySemver: (semver: string) => IapVersion | undefined;

package/dist/core/version-map.js

@@ -0,0 +1,45 @@
+export const IAP_VERSIONS = [
+    { semver: "8.0.19", label: "2018-Spring", codename: "Skylark" },
+    { semver: "8.0.20", label: "2018-Summer", codename: "Tiffany" },
+    { semver: "8.0.21", label: "2018-Winter", codename: "Urara" },
+    { semver: "8.0.22", label: "2019-Spring", codename: "Violette" },
+    { semver: "8.0.23", label: "2019-Summer", codename: "Waltz" },
+    { semver: "8.0.24", label: "2019-Winter", codename: "Xanadu" },
+    { semver: "8.0.25", label: "2020-Spring", codename: "Yorkshire" },
+    { semver: "8.0.26", label: "2020-Summer", codename: "Zephirine" },
+    { semver: "8.0.27", label: "2020-Winter", codename: "Azalea" },
+    { semver: "8.0.28", label: "2021-Spring", codename: "Bergamot" },
+    { semver: "8.0.29", label: "2021-Summer", codename: "Cattleya" },
+    { semver: "8.0.30", label: "2021-Winter", codename: "Dandelion" },
+    { semver: "8.0.31", label: "2022-Spring", codename: "Eustoma" },
+    { semver: "8.0.32", label: "2022-Winter", codename: "Freesia" },
+    { semver: "8.0.33", label: "2023-Spring", codename: "Gerbera" },
+    { semver: "8.0.34", label: "2023-Autumn", codename: "Hollyhock" },
+    { semver: "8.0.35", label: "2024-Spring", codename: "Iris" },
+    { semver: "8.0.36", label: "2024-Autumn", codename: "Jasmine" },
+    { semver: "8.0.37", label: "2025-Spring", codename: "Kamille" },
+    { semver: "8.0.38", label: "2025-Autumn", codename: "Lilac" },
+    { semver: "8.0.39", label: "2026-Spring", codename: "Mimosa" },
+];
+export const SELECTABLE_VERSIONS = IAP_VERSIONS.filter((v) => {
+    const minor = parseInt(v.semver.split(".")[2], 10);
+    return minor >= 35; // 2024-Spring (8.0.35) and later
+});
+const labelToVersionMap = new Map(IAP_VERSIONS.map((v) => [v.label, v]));
+const semverToVersionMap = new Map(IAP_VERSIONS.map((v) => [v.semver, v]));
+export const labelToSemver = (label) => {
+    const version = labelToVersionMap.get(label);
+    if (!version) {
+        throw new Error(`Unknown iAP version label: ${label}`);
+    }
+    return version.semver;
+};
+export const semverToLabel = (semver) => {
+    const version = semverToVersionMap.get(semver);
+    if (!version) {
+        throw new Error(`Unknown iAP semver: ${semver}`);
+    }
+    return version.label;
+};
+export const findByLabel = (label) => labelToVersionMap.get(label);
+export const findBySemver = (semver) => semverToVersionMap.get(semver);

package/dist/i18n/en.d.ts

@@ -0,0 +1 @@
+export declare const messages: Record<string, string>;