@hi-man/himan 0.3.5 → 0.4.1

package/dist/adapters/source/git-source-adapter.js

@@ -1,5 +1,6 @@
 import { RepoManager } from "../git/repo-manager.js";
 import { ResourceScanner } from "../resource/resource-scanner.js";
+import { buildResourceAnalysisMetadata } from "../resource/resource-analysis.js";
 import semver from "semver";
 import { HimanError, errorCodes } from "../../utils/errors.js";
 import { promises as fs } from "node:fs";
@@ -85,19 +86,13 @@ export class GitSourceAdapter {
         if (resourceExists && !options.force) {
             throw new HimanError(errorCodes.RESOURCE_EXISTS, `Resource already exists: ${type}/${name}`);
         }
+        const entryContent = this.getDefaultContent(type, name);
         const files = [path.join(resourceDir, "himan.yaml"), path.join(resourceDir, entry)];
         if (!options.dryRun) {
             await fs.rm(resourceDir, { recursive: true, force: true });
             await fs.mkdir(resourceDir, { recursive: true });
-            await fs.writeFile(path.join(resourceDir, "himan.yaml"), YAML.stringify({
-                name,
-                type,
-                version: "0.1.0",
-                entry,
-                description: options.description ?? `${type} resource ${name}`,
-                agents,
-            }), "utf8");
-            await fs.writeFile(path.join(resourceDir, entry), this.getDefaultContent(type, name), "utf8");
+            await fs.writeFile(path.join(resourceDir, "himan.yaml"), YAML.stringify(this.buildCreateResourceMetadata(type, name, entry, entryContent, options.description ?? `${type} resource ${name}`, agents)), "utf8");
+            await fs.writeFile(path.join(resourceDir, entry), entryContent, "utf8");
             await this.maintainSourceDocs(repoDir, {
                 section: resourceExists ? "Changed" : "Added",
                 line: resourceExists
@@ -113,6 +108,73 @@ export class GitSourceAdapter {
             dryRun: Boolean(options.dryRun),
         };
     }
+    async rename(type, oldName, newName, options = {}) {
+        const repoDir = this.getRepoDir();
+        const typeDir = this.getTypeDir(type);
+        const previousResourceDir = path.join(repoDir, typeDir, oldName);
+        const resourceDir = path.join(repoDir, typeDir, newName);
+        if (!(await this.exists(previousResourceDir))) {
+            throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `Resource not found: ${type}/${oldName}`);
+        }
+        await this.ensureRenameTargetAvailable(repoDir, type, newName, resourceDir);
+        const history = await this.history(type, oldName);
+        const latestVersion = history[0]?.version;
+        const tag = latestVersion ? `${type}/${newName}@${latestVersion}` : undefined;
+        if (options.dryRun) {
+            return {
+                type,
+                oldName,
+                newName,
+                previousResourceDir,
+                resourceDir,
+                latestVersion,
+                tag,
+                committed: false,
+                dryRun: true,
+            };
+        }
+        await fs.mkdir(path.dirname(resourceDir), { recursive: true });
+        await fs.rename(previousResourceDir, resourceDir);
+        await this.updateRenamedResourceMetadata(resourceDir, type, oldName, newName);
+        const versionOverrides = latestVersion
+            ? new Map([[this.getResourceVersionOverrideKey(type, newName), latestVersion]])
+            : new Map();
+        const docsPaths = await this.maintainSourceDocs(repoDir, {
+            section: "Changed",
+            line: `- Renamed \`${type}/${oldName}\` to \`${type}/${newName}\`.`,
+        }, versionOverrides);
+        const changedPaths = [
+            path.relative(repoDir, previousResourceDir),
+            path.relative(repoDir, resourceDir),
+            ...docsPaths.map((docPath) => path.relative(repoDir, docPath)),
+        ];
+        if (tag) {
+            await this.repoManager.commitTagAndPush(repoDir, `rename ${type}/${oldName} to ${type}/${newName}`, tag, undefined, changedPaths);
+            return {
+                type,
+                oldName,
+                newName,
+                previousResourceDir,
+                resourceDir,
+                latestVersion,
+                tag,
+                committed: true,
+                dryRun: false,
+            };
+        }
+        const committed = await this.repoManager.commitAndPush(repoDir, `rename ${type}/${oldName} to ${type}/${newName}`, undefined, changedPaths);
+        return {
+            type,
+            oldName,
+            newName,
+            previousResourceDir,
+            resourceDir,
+            latestVersion,
+            tag,
+            committed,
+            dryRun: false,
+        };
+    }
     async initDocs(options = {}) {
         const repoDir = this.getRepoDir();
         const files = [
@@ -147,6 +209,13 @@ export class GitSourceAdapter {
             committed,
         };
     }
+    async cloneTo(targetRepo, options = {}) {
+        return this.repoManager.cloneManagedSourceRefs(this.getRepoDir(), targetRepo, options);
+    }
+    async syncLatestTo(targetRepo, options = {}) {
+        const resources = await this.collectLatestVersionedResources();
+        return this.repoManager.syncLatestSourceSnapshot(this.getRepoDir(), targetRepo, resources, options);
+    }
     getRepoDir() {
         if (!this.sourceConfig?.repoDir) {
             throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "Git source is not initialized.");
@@ -171,6 +240,65 @@ export class GitSourceAdapter {
             return false;
         }
     }
+    async ensureRenameTargetAvailable(repoDir, type, newName, resourceDir) {
+        if (await this.exists(resourceDir)) {
+            throw new HimanError(errorCodes.RESOURCE_EXISTS, `Resource already exists: ${type}/${newName}`);
+        }
+        const [resources, history] = await Promise.all([
+            this.scanner.scanByType(repoDir, type),
+            this.history(type, newName),
+        ]);
+        if (resources.some((resource) => resource.name === newName) || history.length > 0) {
+            throw new HimanError(errorCodes.RESOURCE_EXISTS, `Resource already exists: ${type}/${newName}`);
+        }
+    }
+    async updateRenamedResourceMetadata(resourceDir, type, oldName, newName) {
+        const yamlPath = path.join(resourceDir, "himan.yaml");
+        if (await this.exists(yamlPath)) {
+            const raw = await fs.readFile(yamlPath, "utf8");
+            let parsed;
+            try {
+                parsed = YAML.parse(raw);
+            }
+            catch (error) {
+                throw this.invalidResourceMetadata(type, oldName, "himan.yaml is not valid YAML.", { yamlPath, reason: error instanceof Error ? error.message : String(error) });
+            }
+            if (!this.isRecord(parsed)) {
+                throw this.invalidResourceMetadata(type, oldName, "himan.yaml must be an object.", { yamlPath });
+            }
+            await fs.writeFile(yamlPath, YAML.stringify({
+                ...parsed,
+                name: newName,
+            }), "utf8");
+            return;
+        }
+        if (type !== "skill")
+            return;
+        await this.updateSkillFrontMatterName(path.join(resourceDir, this.getDefaultEntry(type)), oldName, newName);
+    }
+    async updateSkillFrontMatterName(skillPath, oldName, newName) {
+        if (!(await this.exists(skillPath)))
+            return;
+        const raw = await fs.readFile(skillPath, "utf8");
+        const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw);
+        if (!match)
+            return;
+        let parsed;
+        try {
+            parsed = YAML.parse(match[1]);
+        }
+        catch {
+            return;
+        }
+        if (!this.isRecord(parsed) || parsed.name !== oldName)
+            return;
+        const frontMatter = YAML.stringify({
+            ...parsed,
+            name: newName,
+        }).trimEnd();
+        const updated = `---\n${frontMatter}\n---\n${raw.slice(match[0].length)}`;
+        await fs.writeFile(skillPath, updated, "utf8");
+    }
     async validatePublishResource(type, name, resourceDir) {
         const yamlPath = path.join(resourceDir, "himan.yaml");
         if (!(await this.exists(yamlPath))) {
@@ -406,6 +534,25 @@ export class GitSourceAdapter {
         }
         return `# ${name}\n\nDescribe skill workflow here.\n`;
     }
+    buildCreateResourceMetadata(type, name, entry, entryContent, description, agents) {
+        const metadata = {
+            name,
+            type,
+            version: "0.1.0",
+            entry,
+            description,
+            agents,
+        };
+        if (type === "skill") {
+            metadata.analysis = buildResourceAnalysisMetadata({
+                entry,
+                entryContent,
+                measuredBy: "himan",
+                generatedBy: "himan",
+            });
+        }
+        return metadata;
+    }
     async buildReadmeContent(repoDir, versionOverrides = new Map()) {
         const resourceLines = await this.buildResourceIndex(repoDir, versionOverrides);
         const repo = this.sourceConfig?.repo ?? "<git_url>";
@@ -666,6 +813,38 @@ export class GitSourceAdapter {
             return undefined;
         }
     }
+    async collectLatestVersionedResources() {
+        const repoDir = this.getRepoDir();
+        const resources = [];
+        for (const type of RESOURCE_TYPES) {
+            const scanned = await this.scanner.scanByType(repoDir, type);
+            for (const resource of scanned) {
+                const history = await this.history(type, resource.name);
+                const latest = history[0];
+                const metadataVersion = await this.readResourceVersion(repoDir, type, resource.name);
+                const version = latest?.version ?? metadataVersion;
+                if (!version || !semver.valid(version)) {
+                    throw new HimanError(errorCodes.VERSION_NOT_FOUND, `Latest version not found for ${type}/${resource.name}.`);
+                }
+                resources.push({
+                    type,
+                    name: resource.name,
+                    version,
+                    tag: `${type}/${resource.name}@${version}`,
+                    sourceRef: latest ? latest.raw : undefined,
+                    sourcePath: latest
+                        ? undefined
+                        : path.join(repoDir, this.getTypeDir(type), resource.name),
+                });
+            }
+        }
+        return resources.sort((a, b) => {
+            const typeOrder = RESOURCE_TYPES.indexOf(a.type) - RESOURCE_TYPES.indexOf(b.type);
+            if (typeOrder !== 0)
+                return typeOrder;
+            return a.name.localeCompare(b.name);
+        });
+    }
     async getResourceRef(repoDir, type, name, versionOverrides = new Map()) {
         const version = versionOverrides.get(this.getResourceVersionOverrideKey(type, name)) ??
             (await this.readLatestTaggedResourceVersion(repoDir, type, name)) ??

package/dist/adapters/source/registry-source-adapter.js

@@ -18,6 +18,9 @@ export class RegistrySourceAdapter {
     async create(_type, _name, _options) {
         throw new HimanError(errorCodes.NOT_IMPLEMENTED, "Registry source is reserved for phase 2.");
     }
+    async rename(_type, _oldName, _newName, _options) {
+        throw new HimanError(errorCodes.NOT_IMPLEMENTED, "Registry source is reserved for phase 2.");
+    }
     async initDocs(_options) {
         throw new HimanError(errorCodes.NOT_IMPLEMENTED, "Registry source is reserved for phase 2.");
     }

package/dist/cli/builders.js

@@ -1,5 +1,6 @@
 import { ServiceFactory } from "../services/index.js";
 import { registerAgentCommands } from "./agent-commands.js";
+import { registerDoctorCommand } from "./doctor-command.js";
 import { registerProjectCommands } from "./project-commands.js";
 import { registerResourceCommands } from "./resource-commands.js";
 import { registerInitCommand, registerSourceCommands } from "./source-commands.js";
@@ -9,6 +10,7 @@ export function buildCli() {
     const services = new ServiceFactory();
     appendCommandGroupsHelp(program);
     registerInitCommand(program, services);
+    registerDoctorCommand(program, services);
     const sourceCmd = program.command("source").description("Manage source repositories");
     registerSourceCommands(sourceCmd, services, { includeInit: true });
     const resourceCmd = program
@@ -60,14 +62,17 @@ function appendCommandGroupsHelp(program) {
     program.addHelpText("after", `
 Command groups:
   source   Data source management (git now, registry reserved)
-           init, source init, source add, source use, source list, source init-docs
+           init, source init, source add, source use, source list,
+           source init-docs, source clone, source sync
   resource Source resource discovery and metadata
-           list, list --installed, history, create,
-           resource list, resource history, resource create
+           list, list --installed, history, create, rename (not recommended yet),
+           resource list, resource history, resource create, resource rename
   project  Resource usage lifecycle in current project or user-level agent dirs
            list, install, dev, uninstall, publish,
            project list, project install, project dev, project uninstall, project publish
   agent    Default agent configuration
            agent list, agent use, agent current, agent clear
+  doctor   Runtime and project health checks
+           doctor
 `);
 }

package/dist/cli/doctor-command.js

@@ -0,0 +1,30 @@
+import { runAction } from "./shared.js";
+export function registerDoctorCommand(command, services) {
+    command
+        .command("doctor")
+        .option("--json", "output json format")
+        .description("Check Himan runtime and project health")
+        .action(async (options) => {
+        await runAction(async () => {
+            const result = await services.doctor(process.cwd());
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                writeDoctorResult(result);
+            }
+            if (!result.ok) {
+                process.exitCode = 1;
+            }
+        });
+    });
+}
+function writeDoctorResult(result) {
+    process.stdout.write("Himan doctor\n");
+    for (const check of result.checks) {
+        process.stdout.write(`${formatCheckStatus(check)} ${check.name}: ${check.message}\n`);
+    }
+}
+function formatCheckStatus(check) {
+    return `[${check.status}]`;
+}

package/dist/cli/project-commands.js

@@ -82,7 +82,11 @@ export function registerProjectCommands(command, services, options = {}) {
         await runAction(async () => {
             const resourceType = ensureResourceType(type);
             const result = await services.dev(resourceType, name, process.cwd());
-            process.stdout.write(`Switched ${result.type}/${result.name} to dev mode: ${result.devPath}\n`);
+            if (result.sourceScope === "global") {
+                process.stdout.write(`Copied global ${result.type}/${result.name} into current project: ${result.devPath}\n`);
+                return;
+            }
+            process.stdout.write(`Editing ${result.type}/${result.name} in place: ${result.devPath}\n`);
         });
     });
     command
@@ -104,13 +108,23 @@ export function registerProjectCommands(command, services, options = {}) {
         .option("--patch", "patch release")
         .option("--minor", "minor release")
         .option("--major", "major release")
+        .option("--global", "install the published version into user-level agent directories")
         .description("Publish resource (default: --patch)")
         .action(async (type, name, options) => {
         await runAction(async () => {
             const resourceType = ensureResourceType(type);
             const releaseType = resolveReleaseType(options);
-            const result = await services.publish(resourceType, name, releaseType, process.cwd());
-            process.stdout.write(`Published ${result.type}/${result.name}@${result.version}\n`);
+            const installScope = options.global ? "global" : "project";
+            process.stdout.write(options.global
+                ? "Published resource will be installed globally; current project lock will not be updated.\n"
+                : "Published resource will be installed into the current project and recorded in himan.lock. Use --global to install globally instead.\n");
+            const result = await services.publish(resourceType, name, releaseType, process.cwd(), {
+                installScope,
+                onProgress: (progress) => {
+                    process.stdout.write(`[publish:${progress.stage}] ${progress.message}\n`);
+                },
+            });
+            process.stdout.write(`Published ${result.type}/${result.name}@${result.version} and installed ${result.installScope === "global" ? "globally" : "into current project"}\n`);
         });
     });
 }

package/dist/cli/resource-commands.js

@@ -91,6 +91,29 @@ export function registerResourceCommands(command, services) {
             process.stdout.write(`Created ${result.type}/${result.name} at ${result.resourceDir}${result.dryRun ? " (dry-run)" : ""}\n`);
         });
     });
+    command
+        .command("rename")
+        .argument("<type>", "resource type")
+        .argument("<old-name>", "current resource name")
+        .argument("<new-name>", "new resource name")
+        .option("--dry-run", "show rename result without writing")
+        .option("--no-project", "do not migrate current project install targets or lock")
+        .option("--json", "output json format")
+        .description("Rename resource in current default source (not recommended yet)")
+        .action(async (type, oldName, newName, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.rename(resourceType, oldName, newName, process.cwd(), {
+                dryRun: options.dryRun,
+                migrateProject: options.project,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Renamed ${result.type}/${result.oldName} to ${result.type}/${result.newName}${result.dryRun ? " (dry-run)" : ""}\n`);
+        });
+    });
 }
 async function writeInstalledList(services, type, agents, json) {
     if (!type) {

package/dist/cli/source-commands.js

@@ -1,12 +1,41 @@
+import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { HimanError, errorCodes } from "../utils/errors.js";
 import { runAction } from "./shared.js";
 export function registerInitCommand(command, services) {
     command
         .command("init")
         .argument("<git_repo>", "Git repository URL")
-        .action(async (gitRepo) => {
+        .option("--agent <list>", "set current project default agents, comma separated")
+        .option("--install <refs>", "install resource refs after init, comma separated: rule/name[@version]")
+        .option("--mode <mode>", "install mode for --install: link or copy")
+        .option("--json", "output json format")
+        .action(async (gitRepo, options) => {
         await runAction(async () => {
-            const result = await services.initSource("git", gitRepo);
-            process.stdout.write(`Initialized ${result.sourceType} source: ${result.repo}\n`);
+            const agents = parseAgents(options.agent);
+            const installRefs = parseInstallRefs(options.install);
+            const mode = parseInstallMode(options.mode);
+            if (mode && installRefs.length === 0) {
+                throw new HimanError(errorCodes.CLI_USAGE, "Use --mode only with --install.");
+            }
+            const source = await services.initSource("git", gitRepo);
+            const agentResult = agents?.length
+                ? await services.setAgents(agents, "project", process.cwd())
+                : undefined;
+            const installed = [];
+            for (const ref of installRefs) {
+                installed.push(await services.install(ref.type, ref.name, ref.version, process.cwd(), agents, mode));
+            }
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ source, agents: agentResult, installed }, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Initialized ${source.sourceType} source: ${source.repo}\n`);
+            if (agentResult) {
+                process.stdout.write(`Using agents (${agentResult.scope}): ${agentResult.agents.join(", ")}\n`);
+            }
+            for (const item of installed) {
+                process.stdout.write(`Installed ${item.type}/${item.name}@${item.version}\n`);
+            }
         });
     });
 }
@@ -35,6 +64,80 @@ export function registerSourceCommands(command, services, options) {
             process.stdout.write(`Using source: ${result.name}\n`);
         });
     });
+    command
+        .command("clone")
+        .argument("<from>", "source name or git repository URL")
+        .argument("<to>", "target source name or git repository URL")
+        .option("--branch <branch>", "source branch to clone")
+        .option("--target-branch <branch>", "target branch name")
+        .option("--add-source <name>", "add the target git repo as a named source after clone")
+        .option("--use", "switch default source to the target source after clone")
+        .option("--dry-run", "show refs without pushing")
+        .option("--json", "output json format")
+        .description("Clone a git source into an empty target git repository")
+        .action(async (from, to, options) => {
+        await runAction(async () => {
+            const result = await services.cloneSource(from, to, {
+                branch: options.branch,
+                targetBranch: options.targetBranch,
+                addSource: options.addSource,
+                use: options.use,
+                dryRun: options.dryRun,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Source clone ${result.dryRun ? "dry-run" : "completed"}: ${result.source.name ?? result.source.repo} -> ${result.target.name ?? result.target.repo}\n`);
+            process.stdout.write(`- branch ${result.branch} -> ${result.targetBranch}\n`);
+            process.stdout.write(`- resource tags: ${result.tags.length}\n`);
+            if (result.addedSource) {
+                process.stdout.write(`- added source: ${result.addedSource}\n`);
+            }
+            if (result.usedSource) {
+                process.stdout.write(`- using source: ${result.usedSource}\n`);
+            }
+        });
+    });
+    command
+        .command("sync")
+        .argument("<from>", "source name or git repository URL")
+        .argument("<to>", "target source name or git repository URL")
+        .option("--target-branch <branch>", "target branch name", "main")
+        .option("--add-source <name>", "add the target git repo as a named source after sync")
+        .option("--use", "switch default source to the target source after sync")
+        .option("--dry-run", "show resources without pushing")
+        .option("--json", "output json format")
+        .description("Sync latest source resource snapshots into a target git repository")
+        .action(async (from, to, options) => {
+        await runAction(async () => {
+            const result = await services.syncSource(from, to, {
+                targetBranch: options.targetBranch,
+                addSource: options.addSource,
+                use: options.use,
+                dryRun: options.dryRun,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            const created = result.resources.filter((resource) => resource.action === "created").length;
+            const skipped = result.resources.length - created;
+            process.stdout.write(`Source sync ${result.dryRun ? "dry-run" : "completed"}: ${result.source.name ?? result.source.repo} -> ${result.target.name ?? result.target.repo}\n`);
+            process.stdout.write(`- target branch: ${result.targetBranch}\n`);
+            process.stdout.write(`- resources: ${result.resources.length}\n`);
+            process.stdout.write(`- tags created: ${created}\n`);
+            if (skipped > 0) {
+                process.stdout.write(`- tags skipped: ${skipped}\n`);
+            }
+            if (result.addedSource) {
+                process.stdout.write(`- added source: ${result.addedSource}\n`);
+            }
+            if (result.usedSource) {
+                process.stdout.write(`- using source: ${result.usedSource}\n`);
+            }
+        });
+    });
     command
         .command("list")
         .option("--json", "output json format")
@@ -84,3 +187,67 @@ export function registerSourceCommands(command, services, options) {
         });
     });
 }
+function ensureResourceType(type) {
+    if (type !== "rule" && type !== "command" && type !== "skill") {
+        throw new HimanError(errorCodes.UNSUPPORTED_RESOURCE_TYPE, `Unsupported resource type: ${type}`);
+    }
+    return type;
+}
+function parseInstallRefs(input) {
+    if (!input)
+        return [];
+    const refs = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (refs.length === 0) {
+        throw new HimanError(errorCodes.INVALID_INPUT, "Install list cannot be empty.");
+    }
+    return refs.map((ref) => {
+        const parts = ref.split("/");
+        if (parts.length !== 2 || !parts[0] || !parts[1]) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Invalid install ref: ${ref}. Use type/name[@version].`);
+        }
+        const { name, version } = parseNameVersion(parts[1]);
+        if (!name) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Invalid install ref: ${ref}. Use type/name[@version].`);
+        }
+        return {
+            type: ensureResourceType(parts[0]),
+            name,
+            version,
+        };
+    });
+}
+function parseNameVersion(input) {
+    const idx = input.lastIndexOf("@");
+    if (idx <= 0)
+        return { name: input };
+    return { name: input.slice(0, idx), version: input.slice(idx + 1) };
+}
+function parseInstallMode(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "link" || normalized === "copy") {
+        return normalized;
+    }
+    throw new HimanError(errorCodes.INVALID_INPUT, `Unsupported install mode: ${input}. Supported modes: link, copy`);
+}
+function parseAgents(input) {
+    if (!input)
+        return undefined;
+    const agents = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (agents.length === 0)
+        return undefined;
+    const supported = getSupportedAgentNames();
+    for (const agent of agents) {
+        if (!normalizeAgent(agent)) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Unsupported agent: ${agent}. Supported agents: ${supported.join(", ")}`);
+        }
+    }
+    return agents;
+}

package/dist/domain/doctor.js

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

package/dist/domain/source-transfer.js

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