@intra-mart/accel 0.1.0-dev-20260420

package/dist/markdown/section-replacement.js

@@ -0,0 +1,68 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { evaluateCondition } from "../core/condition-evaluator.js";
+const findSectionRange = (tree, heading) => {
+    let startIdx = -1;
+    let headingDepth = 0;
+    for (let i = 0; i < tree.children.length; i++) {
+        const node = tree.children[i];
+        if (startIdx === -1) {
+            // Looking for the target heading
+            if (node.type === "heading") {
+                const text = extractHeadingText(node);
+                if (text === heading) {
+                    startIdx = i;
+                    headingDepth = node.depth;
+                }
+            }
+        }
+        else {
+            // Looking for the end of the section (same or higher level heading)
+            if (node.type === "heading" && node.depth <= headingDepth) {
+                return { start: startIdx, end: i };
+            }
+        }
+    }
+    if (startIdx !== -1) {
+        // Section extends to end of document
+        return { start: startIdx, end: tree.children.length };
+    }
+    return null;
+};
+const extractHeadingText = (node) => {
+    if (node.type !== "heading")
+        return "";
+    return node.children
+        .map((child) => {
+        if (child.type === "text")
+            return child.value;
+        if ("children" in child) {
+            return child.children
+                .map((c) => c.value ?? "")
+                .join("");
+        }
+        return "";
+    })
+        .join("");
+};
+export const applySectionReplacements = (content, replacements, context) => {
+    const processor = unified().use(remarkParse).use(remarkStringify);
+    const tree = processor.parse(content);
+    // Process replacements in reverse order to maintain correct indices
+    const removals = [];
+    for (const replacement of replacements) {
+        if (!evaluateCondition(replacement.condition, context)) {
+            const range = findSectionRange(tree, replacement.heading);
+            if (range) {
+                removals.push(range);
+            }
+        }
+    }
+    // Sort removals in reverse order and apply
+    removals.sort((a, b) => b.start - a.start);
+    for (const { start, end } of removals) {
+        tree.children.splice(start, end - start);
+    }
+    return processor.stringify(tree);
+};

package/dist/markdown/text-replacement.d.ts

@@ -0,0 +1,8 @@
+import type { TextReplacement, EvalContext } from "../core/types.js";
+export type PlaceholderMatcher = (text: string, target: string) => {
+    index: number;
+    length: number;
+}[];
+export declare const defaultPlaceholderMatcher: PlaceholderMatcher;
+export declare const resolveTextValue: (replacement: TextReplacement, context: EvalContext) => string;
+export declare const applyTextReplacements: (content: string, replacements: TextReplacement[], context: EvalContext, matcher?: PlaceholderMatcher) => string;

package/dist/markdown/text-replacement.js

@@ -0,0 +1,32 @@
+import { evaluateCondition } from "../core/condition-evaluator.js";
+import { interpolateVariables } from "../core/variable-interpolator.js";
+export const defaultPlaceholderMatcher = (text, target) => {
+    const matches = [];
+    let idx = text.indexOf(target);
+    while (idx !== -1) {
+        matches.push({ index: idx, length: target.length });
+        idx = text.indexOf(target, idx + target.length);
+    }
+    return matches;
+};
+export const resolveTextValue = (replacement, context) => {
+    // first-match-wins
+    for (const entry of replacement.values) {
+        if (evaluateCondition(entry.condition, context)) {
+            return entry.value;
+        }
+    }
+    return "";
+};
+export const applyTextReplacements = (content, replacements, context, matcher = defaultPlaceholderMatcher) => {
+    let result = content;
+    for (const replacement of replacements) {
+        const rawValue = resolveTextValue(replacement, context);
+        const value = interpolateVariables(rawValue, context);
+        // Simple string replacement — replace all occurrences
+        while (matcher(result, replacement.target).length > 0) {
+            result = result.replace(replacement.target, value);
+        }
+    }
+    return result;
+};

package/dist/utils/archive.d.ts

@@ -0,0 +1,3 @@
+export declare const extractTarGz: (archivePath: string, destDir: string) => Promise<void>;
+export declare const createTarGz: (sourceDir: string, destPath: string, entries?: string[]) => Promise<void>;
+export declare const createTempDir: (prefix?: string) => Promise<string>;

package/dist/utils/archive.js

@@ -0,0 +1,20 @@
+import { extract, create } from "tar";
+import { mkdtemp } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+export const extractTarGz = async (archivePath, destDir) => {
+    await extract({
+        file: archivePath,
+        cwd: destDir,
+    });
+};
+export const createTarGz = async (sourceDir, destPath, entries) => {
+    await create({
+        gzip: true,
+        file: destPath,
+        cwd: sourceDir,
+    }, entries ?? ["."]);
+};
+export const createTempDir = async (prefix = "accel-") => {
+    return mkdtemp(join(tmpdir(), prefix));
+};

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare const computeSha1: (content: string | Buffer) => string;

package/dist/utils/hash.js

@@ -0,0 +1,6 @@
+import { createHash } from "node:crypto";
+export const computeSha1 = (content) => {
+    const hash = createHash("sha1");
+    hash.update(content);
+    return hash.digest("hex");
+};

package/dist/utils/locale-detect.d.ts

@@ -0,0 +1,2 @@
+export declare const detectLocale: () => string;
+export declare const normalizeLocale: (raw: string) => string;

package/dist/utils/locale-detect.js

@@ -0,0 +1,35 @@
+import { LOCALE_OPTIONS } from "../core/constants.js";
+const LOCALE_NORMALIZE_MAP = {
+    ja: "ja",
+    ja_jp: "ja",
+    en: "en",
+    en_us: "en",
+    en_gb: "en",
+    zh_cn: "zh_CN",
+    zh: "zh_CN",
+};
+const DEFAULT_LOCALE = "en";
+export const detectLocale = () => {
+    const envLocale = process.env["LC_ALL"] ||
+        process.env["LC_MESSAGES"] ||
+        process.env["LANG"] ||
+        process.env["LANGUAGE"] ||
+        "";
+    return normalizeLocale(envLocale);
+};
+export const normalizeLocale = (raw) => {
+    // Strip encoding (e.g., ".UTF-8")
+    const stripped = raw.split(".")[0].toLowerCase();
+    const matched = LOCALE_NORMALIZE_MAP[stripped];
+    if (matched)
+        return matched;
+    // Try language part only (e.g., "ja_JP" -> "ja")
+    const langPart = stripped.split("_")[0];
+    const langMatched = LOCALE_NORMALIZE_MAP[langPart];
+    if (langMatched)
+        return langMatched;
+    // Check if it's directly a supported locale
+    if (LOCALE_OPTIONS.includes(raw))
+        return raw;
+    return DEFAULT_LOCALE;
+};

package/dist/utils/settings-io.d.ts

@@ -0,0 +1,7 @@
+import type { AccelSettings, HashsumEntry } from "../core/types.js";
+export declare const writeSettings: (projectDir: string, settings: AccelSettings) => Promise<void>;
+export declare const readSettings: (projectDir: string) => Promise<AccelSettings>;
+export declare const serializeHashsum: (entries: HashsumEntry[]) => string;
+export declare const parseHashsum: (content: string) => HashsumEntry[];
+export declare const writeHashsum: (projectDir: string, entries: HashsumEntry[]) => Promise<void>;
+export declare const readHashsum: (projectDir: string) => Promise<HashsumEntry[]>;

package/dist/utils/settings-io.js

@@ -0,0 +1,54 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+const ACCEL_DIR = ".accel";
+const SETTINGS_FILE = "settings.json";
+const HASHSUM_FILE = "hashsum.txt";
+const ensureAccelDir = async (projectDir) => {
+    const accelDir = join(projectDir, ACCEL_DIR);
+    await mkdir(accelDir, { recursive: true });
+    return accelDir;
+};
+// --- settings.json ---
+export const writeSettings = async (projectDir, settings) => {
+    const accelDir = await ensureAccelDir(projectDir);
+    const filePath = join(accelDir, SETTINGS_FILE);
+    await writeFile(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+};
+export const readSettings = async (projectDir) => {
+    const filePath = join(projectDir, ACCEL_DIR, SETTINGS_FILE);
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+};
+// --- hashsum.txt ---
+export const serializeHashsum = (entries) => {
+    const sorted = [...entries].sort((a, b) => a.filePath.localeCompare(b.filePath));
+    return sorted
+        .map((e) => `${e.filePath}@${e.version} sha1:${e.sha1}`)
+        .join("\n") + "\n";
+};
+export const parseHashsum = (content) => {
+    return content
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => {
+        const match = line.match(/^(.+)@(\S+)\s+sha1:(\S+)$/);
+        if (!match) {
+            throw new Error(`Invalid hashsum line: ${line}`);
+        }
+        return {
+            filePath: match[1],
+            version: match[2],
+            sha1: match[3],
+        };
+    });
+};
+export const writeHashsum = async (projectDir, entries) => {
+    const accelDir = await ensureAccelDir(projectDir);
+    const filePath = join(accelDir, HASHSUM_FILE);
+    await writeFile(filePath, serializeHashsum(entries), "utf-8");
+};
+export const readHashsum = async (projectDir) => {
+    const filePath = join(projectDir, ACCEL_DIR, HASHSUM_FILE);
+    const content = await readFile(filePath, "utf-8");
+    return parseHashsum(content);
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@intra-mart/accel",
+  "version": "0.1.0-dev-20260420",
+  "type": "module",
+  "description": "CLI tool for intra-mart Accel Platform development",
+  "author": "NTT DATA INTRAMART",
+  "license": "UNLICENSED",
+  "keywords": [
+    "intra-mart",
+    "AccelPlatform",
+    "iAP"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/accelplatform/accel-cli.git"
+  },
+  "homepage": "http://oss.intra-mart.org",
+  "bin": {
+    "accel": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "assets/assets.tar.gz"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "citty": "^0.1.6",
+    "fast-xml-parser": "^5.2.0",
+    "remark": "^15.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "semver": "^7.7.1",
+    "tar": "^7.4.3",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.2",
+    "@types/semver": "^7.7.0",
+    "execa": "^9.5.2",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
+}