@intra-mart/accel 0.1.0-dev-20260420

package/dist/asset/default-source.d.ts

@@ -0,0 +1 @@
+export declare const defaultAssetSourcePath: () => string;

package/dist/asset/default-source.js

@@ -0,0 +1,9 @@
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+// Layout assumption (both dev and published package):
+//   <root>/dist/asset/default-source.js  (or <root>/src/asset/default-source.ts in dev)
+//   <root>/assets/assets.tar.gz
+export const defaultAssetSourcePath = () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, "..", "..", "assets", "assets.tar.gz");
+};

package/dist/asset/deployer.d.ts

@@ -0,0 +1,14 @@
+import type { AssetProvider, AccelSettings, HashsumEntry } from "../core/types.js";
+export type DeployOptions = {
+    projectDir: string;
+    settings: AccelSettings;
+    provider: AssetProvider;
+    noInstall: boolean;
+    skipExistingFiles?: boolean;
+};
+export type DeployResult = {
+    deployedFiles: string[];
+    hashEntries: HashsumEntry[];
+    skippedFiles: string[];
+};
+export declare const deployAssets: (options: DeployOptions) => Promise<DeployResult>;

package/dist/asset/deployer.js

@@ -0,0 +1,109 @@
+import { readFile, writeFile, mkdir, stat } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { labelToSemver } from "../core/version-map.js";
+import { walkAssetRepo } from "./walker.js";
+import { processMarkdown } from "../markdown/processor.js";
+import { applyRegexReplacements } from "./regex-replacement.js";
+import { computeSha1 } from "../utils/hash.js";
+import { writeSettings, writeHashsum } from "../utils/settings-io.js";
+import { execSync } from "node:child_process";
+const fileExists = async (path) => {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const collectReplacements = (entry) => {
+    if (!entry.meta?.replacements)
+        return [];
+    return entry.meta.replacements;
+};
+export const deployAssets = async (options) => {
+    const { projectDir, settings, provider, noInstall, skipExistingFiles } = options;
+    try {
+        // 1. Fetch assets
+        const repoDir = await provider.fetch();
+        // 2. Build eval context
+        const semver = labelToSemver(settings.accelplatformVersion);
+        const context = {
+            version: semver,
+            modules: settings.modules,
+            locale: settings.locale,
+            agents: settings.agents,
+            name: settings.name,
+            group: settings.group,
+            description: settings.description,
+            accelplatformVersion: settings.accelplatformVersion,
+            database: settings.database,
+            projectVersion: settings.projectVersion,
+        };
+        // 3. Walk and filter
+        const entries = await walkAssetRepo(repoDir, semver, context);
+        // 4. Deploy files
+        const deployedFiles = [];
+        const hashEntries = [];
+        const deployedAssets = {};
+        const skippedFiles = [];
+        for (const entry of entries) {
+            const targetPath = entry.relativePath;
+            const destPath = join(projectDir, targetPath);
+            if (skipExistingFiles && (await fileExists(destPath))) {
+                skippedFiles.push(targetPath);
+                continue;
+            }
+            // Read source file
+            let content = await readFile(entry.sourcePath, "utf-8");
+            // Apply replacements
+            const replacements = collectReplacements(entry);
+            if (replacements.length > 0) {
+                if (targetPath.endsWith(".md")) {
+                    // Markdown: process with remark AST
+                    content = processMarkdown(content, replacements, context);
+                }
+                else {
+                    // Non-markdown: apply regex replacements only
+                    const regexReplacements = replacements.filter((r) => r.type === "regex");
+                    if (regexReplacements.length > 0) {
+                        content = applyRegexReplacements(content, regexReplacements, context);
+                    }
+                }
+            }
+            // Write to project directory
+            await mkdir(dirname(destPath), { recursive: true });
+            await writeFile(destPath, content, "utf-8");
+            // Record hash
+            const sha1 = computeSha1(content);
+            const version = entry.meta?.version ?? "0.0.0";
+            hashEntries.push({ filePath: targetPath, version, sha1 });
+            deployedAssets[targetPath] = version;
+            deployedFiles.push(targetPath);
+        }
+        // 5. Write settings and hashsum
+        const updatedSettings = {
+            ...settings,
+            deployedAssets,
+        };
+        await writeSettings(projectDir, updatedSettings);
+        await writeHashsum(projectDir, hashEntries);
+        // 6. Run install commands at project root
+        if (!noInstall) {
+            const installCmds = ["bun install", "bun run build"];
+            for (const cmd of installCmds) {
+                try {
+                    execSync(cmd, { cwd: projectDir, stdio: "pipe" });
+                }
+                catch {
+                    console.warn(`Warning: install command failed: ${cmd} in ${projectDir}`);
+                }
+            }
+        }
+        return { deployedFiles, hashEntries, skippedFiles };
+    }
+    finally {
+        // 7. Cleanup (delegated to provider)
+        await provider.cleanup().catch(() => { });
+    }
+};

package/dist/asset/file-provider.d.ts

@@ -0,0 +1,2 @@
+import type { AssetProvider } from "../core/types.js";
+export declare const createFileAssetProvider: (sourcePath: string) => AssetProvider;

package/dist/asset/file-provider.js

@@ -0,0 +1,25 @@
+import { stat, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { extractTarGz, createTempDir } from "../utils/archive.js";
+export const createFileAssetProvider = (sourcePath) => {
+    let tmpDir = null;
+    return {
+        fetch: async () => {
+            const st = await stat(sourcePath);
+            if (st.isDirectory()) {
+                return sourcePath;
+            }
+            tmpDir = await createTempDir("accel-assets-");
+            const extractDir = join(tmpDir, "repo");
+            await mkdir(extractDir, { recursive: true });
+            await extractTarGz(sourcePath, extractDir);
+            return extractDir;
+        },
+        cleanup: async () => {
+            if (tmpDir) {
+                await rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+                tmpDir = null;
+            }
+        },
+    };
+};

package/dist/asset/local-provider.d.ts

@@ -0,0 +1,2 @@
+import type { AssetProvider } from "../core/types.js";
+export declare const createLocalAssetProvider: (serverUrl: string) => AssetProvider;

package/dist/asset/local-provider.js

@@ -0,0 +1,45 @@
+import { get } from "node:http";
+import { createWriteStream } from "node:fs";
+import { join } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import { extractTarGz, createTempDir } from "../utils/archive.js";
+const downloadFile = (url, destPath) => {
+    return new Promise((resolve, reject) => {
+        const file = createWriteStream(destPath);
+        get(url, (response) => {
+            if (response.statusCode !== 200) {
+                file.close();
+                reject(new Error(`HTTP ${response.statusCode} when downloading from ${url}`));
+                return;
+            }
+            response.pipe(file);
+            file.on("finish", () => {
+                file.close();
+                resolve();
+            });
+        }).on("error", (err) => {
+            file.close();
+            reject(err);
+        });
+    });
+};
+export const createLocalAssetProvider = (serverUrl) => {
+    let tmpDir = null;
+    return {
+        fetch: async () => {
+            tmpDir = await createTempDir("accel-assets-");
+            const archivePath = join(tmpDir, "assets.tar.gz");
+            const extractDir = join(tmpDir, "repo");
+            await mkdir(extractDir, { recursive: true });
+            await downloadFile(`${serverUrl}/archive`, archivePath);
+            await extractTarGz(archivePath, extractDir);
+            return extractDir;
+        },
+        cleanup: async () => {
+            if (tmpDir) {
+                await rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+                tmpDir = null;
+            }
+        },
+    };
+};

package/dist/asset/regex-replacement.d.ts

@@ -0,0 +1,2 @@
+import type { RegexReplacement, EvalContext } from "../core/types.js";
+export declare const applyRegexReplacements: (content: string, replacements: RegexReplacement[], context: EvalContext) => string;

package/dist/asset/regex-replacement.js

@@ -0,0 +1,12 @@
+import { evaluateCondition } from "../core/condition-evaluator.js";
+import { interpolateVariables } from "../core/variable-interpolator.js";
+export const applyRegexReplacements = (content, replacements, context) => {
+    let result = content;
+    for (const rep of replacements) {
+        if (evaluateCondition(rep.condition, context)) {
+            const interpolated = interpolateVariables(rep.replacement, context);
+            result = result.replace(new RegExp(rep.pattern, "g"), interpolated);
+        }
+    }
+    return result;
+};

package/dist/asset/types.d.ts

@@ -0,0 +1 @@
+export type { AssetProvider } from "../core/types.js";

package/dist/asset/types.js

@@ -0,0 +1 @@
+export {};

package/dist/asset/walker.d.ts

@@ -0,0 +1,10 @@
+import type { MetaJson, EvalContext } from "../core/types.js";
+export type AssetEntry = {
+    /** Absolute path in the extracted repo */
+    sourcePath: string;
+    /** Relative path for deployment (e.g., ".claude/CLAUDE.md") */
+    relativePath: string;
+    /** MetaJson from the directory's _meta.json (or parent's) */
+    meta: MetaJson | null;
+};
+export declare const walkAssetRepo: (repoDir: string, targetSemver: string, context: EvalContext) => Promise<AssetEntry[]>;

package/dist/asset/walker.js

@@ -0,0 +1,165 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, dirname } from "node:path";
+import { evaluateCondition } from "../core/condition-evaluator.js";
+const META_FILE = "_meta.json";
+const readMetaJson = async (dir) => {
+    try {
+        const content = await readFile(join(dir, META_FILE), "utf-8");
+        const parsed = JSON.parse(content);
+        // Default type to "directory" for backward compatibility
+        if (!parsed.type) {
+            parsed.type = "directory";
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Resolve rename rule: evaluate conditions and find the first matching rule.
+ * Returns the source file path and target name, or null if no rule matches.
+ */
+const resolveRenameRule = (rules, context, dir) => {
+    if (!rules || rules.length === 0)
+        return null;
+    for (const rule of rules) {
+        if (evaluateCondition(rule.condition, context)) {
+            return {
+                sourcePath: join(dir, rule.from),
+                targetName: rule.to,
+            };
+        }
+    }
+    return null;
+};
+const findMatchingVersionDirs = async (repoDir, targetSemver) => {
+    const entries = await readdir(repoDir, { withFileTypes: true });
+    const matched = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const dirPath = join(repoDir, entry.name);
+        const meta = await readMetaJson(dirPath);
+        if (!meta) {
+            // No _meta.json — skip version directory without meta
+            continue;
+        }
+        if (meta.conditions) {
+            // Evaluate only the version condition at root level
+            const context = {
+                version: targetSemver,
+                modules: [],
+                locale: "",
+                agents: [],
+                name: "",
+                group: "",
+                description: "",
+                accelplatformVersion: "",
+                database: "",
+                projectVersion: "",
+            };
+            if (evaluateCondition(meta.conditions, context)) {
+                matched.push(dirPath);
+            }
+        }
+    }
+    return matched;
+};
+const walkDirectory = async (dir, baseDir, parentMeta, context) => {
+    const entries = [];
+    const dirEntries = await readdir(dir, { withFileTypes: true });
+    // Check if this directory has its own _meta.json
+    const ownMeta = await readMetaJson(dir);
+    const effectiveMeta = ownMeta ?? parentMeta;
+    // If this directory has conditions and they don't match, skip entirely
+    if (ownMeta?.conditions) {
+        if (!evaluateCondition(ownMeta.conditions, context)) {
+            return [];
+        }
+    }
+    // Handle type: "file" — no recursion into subdirectories
+    if (ownMeta?.type === "file") {
+        const parentRelative = relative(baseDir, dirname(dir));
+        if (ownMeta.rename && ownMeta.rename.length > 0) {
+            // With rename: select one source file via first-match-wins, deploy with `to` name
+            const resolved = resolveRenameRule(ownMeta.rename, context, dir);
+            if (!resolved)
+                return [];
+            const targetPath = parentRelative
+                ? join(parentRelative, resolved.targetName)
+                : resolved.targetName;
+            entries.push({
+                sourcePath: resolved.sourcePath,
+                relativePath: targetPath,
+                meta: effectiveMeta,
+            });
+        }
+        else {
+            // Without rename: deploy all files (except _meta.json) with original names
+            for (const entry of dirEntries) {
+                if (entry.name === META_FILE)
+                    continue;
+                if (!entry.isFile())
+                    continue;
+                const fullPath = join(dir, entry.name);
+                const targetPath = parentRelative
+                    ? join(parentRelative, entry.name)
+                    : entry.name;
+                entries.push({
+                    sourcePath: fullPath,
+                    relativePath: targetPath,
+                    meta: effectiveMeta,
+                });
+            }
+        }
+        return entries;
+    }
+    // type: "directory" — walk recursively (existing behavior)
+    for (const entry of dirEntries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.name === META_FILE) {
+            // Skip _meta.json itself
+            continue;
+        }
+        if (entry.isDirectory()) {
+            const children = await walkDirectory(fullPath, baseDir, effectiveMeta, context);
+            entries.push(...children);
+        }
+        else if (entry.isFile()) {
+            entries.push({
+                sourcePath: fullPath,
+                relativePath: relative(baseDir, fullPath),
+                meta: effectiveMeta,
+            });
+        }
+    }
+    return entries;
+};
+const deduplicateByPath = (entries) => {
+    const byPath = new Map();
+    for (const entry of entries) {
+        const existing = byPath.get(entry.relativePath);
+        if (!existing) {
+            byPath.set(entry.relativePath, entry);
+            continue;
+        }
+        // Same relative path collision: prefer entries from a type: "file" directory.
+        const existingIsFileType = existing.meta?.type === "file";
+        const currentIsFileType = entry.meta?.type === "file";
+        if (currentIsFileType && !existingIsFileType) {
+            byPath.set(entry.relativePath, entry);
+        }
+    }
+    return [...byPath.values()];
+};
+export const walkAssetRepo = async (repoDir, targetSemver, context) => {
+    const versionDirs = await findMatchingVersionDirs(repoDir, targetSemver);
+    const allEntries = [];
+    for (const versionDir of versionDirs) {
+        const meta = await readMetaJson(versionDir);
+        const entries = await walkDirectory(versionDir, versionDir, meta, context);
+        allEntries.push(...entries);
+    }
+    return deduplicateByPath(allEntries);
+};

package/dist/commands/attach.d.ts

@@ -0,0 +1,64 @@
+export declare const attachCommand: import("citty").CommandDef<{
+    "juggling-project": {
+        type: "string";
+        description: string;
+    };
+    "accelplatform-version": {
+        type: "string";
+        description: string;
+    };
+    module: {
+        type: "string";
+        description: string;
+    };
+    name: {
+        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;
+    };
+    "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/attach.js

@@ -0,0 +1,163 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { stat } from "node:fs/promises";
+import { basename, join } 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 attachCommand = defineCommand({
+    meta: {
+        name: "attach",
+        description: "Attach Accel CLI to an existing project",
+    },
+    args: {
+        "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)",
+        },
+        name: {
+            type: "string",
+            description: "Project name",
+        },
+        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)",
+        },
+        "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 projectDir = process.cwd();
+        // Check .accel doesn't exist
+        try {
+            await stat(join(projectDir, ".accel"));
+            p.log.error(getMessage("error.accelExists", locale));
+            process.exit(1);
+        }
+        catch {
+            // .accel doesn't exist — good
+        }
+        const moduleArg = args.module;
+        const modules = moduleArg
+            ? moduleArg.split(",").map((m) => m.trim())
+            : undefined;
+        const agentArg = args.agent;
+        const promptOpts = {
+            name: args.name ?? basename(projectDir),
+            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,
+            noInteraction: args["non-interactive"],
+            isInit: false,
+        };
+        let resolved;
+        try {
+            resolved = await runPrompts(promptOpts);
+        }
+        catch (err) {
+            p.log.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        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: {},
+        };
+        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));
+        const result = await deployAssets({
+            projectDir,
+            settings,
+            provider,
+            noInstall: args["skip-install"],
+            skipExistingFiles: true,
+        });
+        for (const path of result.skippedFiles) {
+            p.log.warn(getMessage("warning.fileExists", locale, { path }));
+        }
+        if (result.skippedFiles.length > 0) {
+            p.log.info(getMessage("attach.skipSummary", locale, {
+                count: String(result.skippedFiles.length),
+            }));
+        }
+        p.log.success(getMessage("progress.complete", locale));
+    },
+});

package/dist/commands/detach.d.ts

@@ -0,0 +1 @@
+export declare const detachCommand: import("citty").CommandDef<{}>;