@bluealba/platform-cli 1.0.1 → 1.1.0

package/dist/index.js

@@ -213,7 +213,7 @@ import { join as join2, dirname as dirname2 } from "path";
 
 // src/utils/template-engine.ts
 import { readdir, readFile, writeFile, mkdir, copyFile, stat, chmod } from "fs/promises";
-import { join, dirname, extname } from "path";
+import { join, dirname, extname, basename } from "path";
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".pem",
   ".crt",
@@ -239,6 +239,13 @@ function applyVariables(text, variables) {
   }
   return result;
 }
+function transformFilename(relativePath) {
+  const base = basename(relativePath);
+  if (base === "gitignore") {
+    return join(dirname(relativePath), ".gitignore");
+  }
+  return relativePath;
+}
 function isBinary(filePath) {
   return BINARY_EXTENSIONS.has(extname(filePath).toLowerCase());
 }
@@ -263,7 +270,7 @@ async function applyTemplate(config, onProgress) {
     const relativePath = srcPath.slice(templateDir4.length + 1);
     if (relativePath.endsWith(".gitkeep")) continue;
     if (exclude.includes(relativePath)) continue;
-    const transformedRelative = applyVariables(relativePath, variables);
+    const transformedRelative = transformFilename(applyVariables(relativePath, variables));
     const destPath = join(outputDir, transformedRelative);
     await mkdir(dirname(destPath), { recursive: true });
     if (isBinary(srcPath)) {
@@ -453,7 +460,6 @@ function buildBootstrapBlock(platformName, applicationName) {
       - NODE_TLS_REJECT_UNAUTHORIZED=0
       - SERVICE_ACCESS_NAME=${applicationName}-bootstrap
       - WAIT_TIME=5000
-      - SYNC_STRATEGY=\${PAE_BOOTSTRAP_SYNC_STRATEGY}
       - GATEWAY_SERVICE_URL=\${PAE_GATEWAY_URL}
       - SERVICE_ACCESS_SECRET=\${PAE_GATEWAY_SERVICE_ACCESS_SECRET}
     volumes:
@@ -481,8 +487,6 @@ function buildBackendBlock(platformName, applicationName, servicePort) {
     build:
       context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
-      args:
-        - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
     ports:
       - ${servicePort}:80
     environment:
@@ -1120,8 +1124,6 @@ async function appendServiceToDockerCompose(dockerComposePath, serviceName, plat
     build:
       context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
-      args:
-        - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
     ports:
       - ${port}:80
     environment:
@@ -1617,7 +1619,7 @@ async function installDependencies(layout, manifest, logger, signal, includeCore
   logger.log(`Installing dependencies in parallel: ${targets.map((t) => t.name).join(", ")}...`);
   await Promise.all(
     targets.map(
-      ({ name, dir }) => runCommand("npm", ["install"], dir, logger, signal).then(() => {
+      ({ name, dir }) => runCommand("npm", ["install", "--prefer-offline"], dir, logger, signal).then(() => {
         logger.log(`\u2713 ${name} install done`);
       })
     )
@@ -2047,8 +2049,8 @@ async function checkIdpProviders(layout) {
     return { configured: false, providers: [], error: `gateway responded with ${response.status}` };
   }
   const data = await response.json();
-  const providers = data.map((p) => ({ name: p.name, type: p.type, active: p.active }));
-  return { configured: providers.length > 0, providers };
+  const providers2 = data.map((p) => ({ name: p.name, type: p.type, active: p.active }));
+  return { configured: providers2.length > 0, providers: providers2 };
 }
 async function gatherStatus() {
   const layout = await findPlatformLayout();
@@ -2268,6 +2270,91 @@ async function removePlatformAdmin(ruleId, logger) {
   return true;
 }
 
+// src/commands/install-ai-plugin/plugins/ba-platform/index.ts
+var baPlatformPlugin = {
+  name: "ba-platform-plugin",
+  description: "Blue Alba Platform knowledge and CLI skills for AI assistants",
+  version: "1.0.0",
+  skills: [
+    {
+      name: "platform",
+      description: "Comprehensive Blue Alba Platform architecture and concepts knowledge",
+      type: "skill",
+      sourceFile: "skills/ba-platform/platform.skill.md"
+    },
+    {
+      name: "platform-cli",
+      description: "Blue Alba Platform CLI commands and usage knowledge",
+      type: "skill",
+      sourceFile: "skills/ba-platform/platform-cli.skill.md"
+    }
+  ]
+};
+
+// src/commands/install-ai-plugin/plugins/registry.ts
+var pluginCatalog = [baPlatformPlugin];
+function findPlugin(name) {
+  return pluginCatalog.find((p) => p.name === name);
+}
+
+// src/commands/install-ai-plugin/install-ai-plugin.command.ts
+var INSTALL_AI_PLUGIN_COMMAND_NAME = "install-ai-plugin";
+var installAiPluginCommand = {
+  name: INSTALL_AI_PLUGIN_COMMAND_NAME,
+  description: "Install AI assistant plugins (skills, MCPs, hooks) for your AI provider"
+};
+async function installAiPlugin(params, context) {
+  const { provider, docsSource, logger, confirmUpdate } = context;
+  for (const pluginName of params.plugins) {
+    const plugin = findPlugin(pluginName);
+    if (!plugin) {
+      logger.log(`Error: Plugin "${pluginName}" not found in catalog.`);
+      continue;
+    }
+    const manifest = await provider.readManifest(pluginName);
+    const diff = provider.calculateDiff(manifest, plugin);
+    const hasStructuralChanges = diff.versionChanged || diff.newSkills.length > 0 || diff.removedSkills.length > 0;
+    if (manifest && hasStructuralChanges) {
+      logger.log(
+        `Plugin "${pluginName}" is already installed (v${diff.currentVersion} \u2192 v${diff.targetVersion}).`
+      );
+      if (diff.newSkills.length > 0) {
+        logger.log(`  New skills: ${diff.newSkills.map((s) => s.name).join(", ")}`);
+      }
+      if (diff.removedSkills.length > 0) {
+        logger.log(`  Removed skills: ${diff.removedSkills.join(", ")}`);
+      }
+      if (diff.existingSkills.length > 0) {
+        logger.log(`  Updated skills: ${diff.existingSkills.map((s) => s.name).join(", ")}`);
+      }
+      if (!params.force && confirmUpdate) {
+        const proceed = await confirmUpdate(diff, plugin);
+        if (!proceed) {
+          logger.log(`Skipped "${pluginName}".`);
+          continue;
+        }
+      }
+      for (const skillName of diff.removedSkills) {
+        await provider.removeSkill(skillName, logger);
+      }
+    } else if (!manifest) {
+      logger.log(`Installing plugin "${pluginName}" v${plugin.version}...`);
+    }
+    for (const skill of plugin.skills) {
+      await provider.installSkill(skill, docsSource, logger);
+    }
+    await provider.writeManifest({
+      plugin: pluginName,
+      version: plugin.version,
+      provider: provider.name,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      skills: plugin.skills.map((s) => s.name)
+    });
+    await provider.updatePermissions(docsSource, logger);
+    logger.log(`Plugin "${pluginName}" v${plugin.version} installed successfully.`);
+  }
+}
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2308,6 +2395,7 @@ for (const cmd of localScriptCommands) {
 }
 registry.register(statusCommand);
 registry.register(managePlatformAdminsCommand);
+registry.register(installAiPluginCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -2405,12 +2493,12 @@ async function configureIdpUiController(ctx) {
     ctx.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const providers = getAllProviders();
+  const providers2 = getAllProviders();
   const providerType = await ctx.select(
     "Select IDP type:",
-    providers.map((p) => ({ label: p.displayName, value: p.type }))
+    providers2.map((p) => ({ label: p.displayName, value: p.type }))
   );
-  const provider = providers.find((p) => p.type === providerType);
+  const provider = providers2.find((p) => p.type === providerType);
   const name = await ctx.prompt("Provider name:");
   const issuer = await ctx.prompt("Issuer URL:");
   const clientId = await ctx.prompt("Client ID:");
@@ -2819,6 +2907,153 @@ async function handleRemove(ctx) {
   ctx.log(`Successfully removed ${successCount} of ${selected.length} admin(s).`);
 }
 
+// src/services/install-ai-plugin.service.ts
+async function installAiPluginService(params, context) {
+  await installAiPlugin(params, context);
+}
+
+// src/commands/install-ai-plugin/providers/claude.provider.ts
+import { homedir as homedir2 } from "os";
+import { join as join26 } from "path";
+import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir3, rm } from "fs/promises";
+var ClaudeProvider = class {
+  name = "claude";
+  baseDir = join26(homedir2(), ".claude");
+  getInstallPath(skillName) {
+    return join26(this.baseDir, "skills", skillName, "SKILL.md");
+  }
+  manifestPath(pluginName) {
+    return join26(this.baseDir, `${pluginName}.manifest.json`);
+  }
+  async readManifest(pluginName) {
+    try {
+      const content = await readFile10(this.manifestPath(pluginName), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async writeManifest(manifest) {
+    await mkdir3(this.baseDir, { recursive: true });
+    await writeFile9(
+      this.manifestPath(manifest.plugin),
+      JSON.stringify(manifest, null, 2),
+      "utf-8"
+    );
+  }
+  calculateDiff(manifest, plugin) {
+    const installedSkills = manifest?.skills ?? [];
+    const targetSkillNames = plugin.skills.map((s) => s.name);
+    return {
+      newSkills: plugin.skills.filter((s) => !installedSkills.includes(s.name)),
+      removedSkills: installedSkills.filter((name) => !targetSkillNames.includes(name)),
+      existingSkills: plugin.skills.filter((s) => installedSkills.includes(s.name)),
+      versionChanged: manifest?.version !== plugin.version,
+      currentVersion: manifest?.version ?? null,
+      targetVersion: plugin.version
+    };
+  }
+  async installSkill(skill, docsSource, logger) {
+    const sourcePath = docsSource.resolve(skill.sourceFile);
+    let content = await readFile10(sourcePath, "utf-8");
+    const docsPath = docsSource.resolve("docs");
+    content = content.replaceAll("{{docsPath}}", docsPath);
+    const installPath = this.getInstallPath(skill.name);
+    await mkdir3(join26(installPath, ".."), { recursive: true });
+    await writeFile9(installPath, content, "utf-8");
+    logger.log(`  Installed skill: ${installPath}`);
+  }
+  async removeSkill(skillName, logger) {
+    const skillDir = join26(this.baseDir, "skills", skillName);
+    try {
+      await rm(skillDir, { recursive: true, force: true });
+      logger.log(`  Removed skill: ${skillDir}`);
+    } catch {
+    }
+  }
+  async updatePermissions(docsSource, logger) {
+    const settingsPath = join26(this.baseDir, "settings.json");
+    const docsPath = docsSource.resolve("docs");
+    let settings = {};
+    try {
+      const content = await readFile10(settingsPath, "utf-8");
+      settings = JSON.parse(content);
+    } catch {
+    }
+    const permissions = settings.permissions ?? {};
+    const additionalDirectories = permissions.additionalDirectories ?? [];
+    if (additionalDirectories.includes(docsPath)) {
+      return;
+    }
+    permissions.additionalDirectories = [...additionalDirectories, docsPath];
+    settings.permissions = permissions;
+    await mkdir3(this.baseDir, { recursive: true });
+    await writeFile9(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    logger.log(`  Granted read access to docs: ${docsPath}`);
+  }
+};
+
+// src/commands/install-ai-plugin/providers/index.ts
+var providers = {
+  claude: () => new ClaudeProvider()
+};
+var providerNames = Object.keys(providers);
+function getProvider(name) {
+  const factory = providers[name];
+  if (!factory) {
+    throw new Error(`Unknown AI provider: "${name}". Available: ${providerNames.join(", ")}`);
+  }
+  return factory();
+}
+
+// src/commands/install-ai-plugin/docs-source/local.docs-source.ts
+import { fileURLToPath as fileURLToPath10 } from "url";
+import { join as join27, dirname as dirname12 } from "path";
+var packageRoot = join27(dirname12(fileURLToPath10(import.meta.url)), "..");
+var LocalDocsSource = class {
+  resolve(relativePath) {
+    return join27(packageRoot, relativePath);
+  }
+};
+
+// src/controllers/ui/install-ai-plugin.ui-controller.ts
+async function installAiPluginUiController(ctx) {
+  const providerName = await ctx.select(
+    "Select AI provider:",
+    providerNames.map((name) => ({
+      label: name.charAt(0).toUpperCase() + name.slice(1),
+      value: name
+    }))
+  );
+  const selectedPlugins = await ctx.multiselect(
+    "Select plugins to install:",
+    pluginCatalog.map((p) => ({
+      label: `${p.name} \u2014 ${p.description}`,
+      value: p.name
+    }))
+  );
+  if (selectedPlugins.length === 0) {
+    ctx.log("No plugins selected.");
+    return;
+  }
+  const provider = getProvider(providerName);
+  const docsSource = new LocalDocsSource();
+  await installAiPluginService(
+    { provider: providerName, plugins: selectedPlugins },
+    {
+      provider,
+      docsSource,
+      logger: ctx,
+      confirmUpdate: async (diff, plugin) => {
+        return ctx.confirm(
+          `Update "${plugin.name}" from v${diff.currentVersion} to v${diff.targetVersion}?`,
+          true
+        );
+      }
+    }
+  );
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
@@ -2832,7 +3067,8 @@ var uiControllers = /* @__PURE__ */ new Map([
   [START_COMMAND_NAME, createLocalScriptUiController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptUiController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)],
-  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController]
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController],
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
@@ -3463,6 +3699,32 @@ async function managePlatformAdminsCliController(args2) {
   }
 }
 
+// src/controllers/cli/install-ai-plugin.cli-controller.ts
+async function installAiPluginCliController(args2) {
+  const { provider: providerName, plugins: pluginsArg, force } = args2;
+  if (!providerName) {
+    console.error('Error: "provider" argument is required (e.g., provider=claude).');
+    process.exit(1);
+  }
+  if (!pluginsArg) {
+    console.error(
+      'Error: "plugins" argument is required (e.g., plugins=ba-platform-plugin).'
+    );
+    process.exit(1);
+  }
+  const plugins = pluginsArg.split(",").map((s) => s.trim());
+  const provider = getProvider(providerName);
+  const docsSource = new LocalDocsSource();
+  await installAiPluginService(
+    { provider: providerName, plugins, force: force === "true" },
+    {
+      provider,
+      docsSource,
+      logger: { log: console.log }
+    }
+  );
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -3476,7 +3738,8 @@ var cliControllers = /* @__PURE__ */ new Map([
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)],
-  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController]
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController],
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginCliController]
 ]);
 
 // src/utils/parse-args.ts

package/docs/404.mdx

@@ -0,0 +1,5 @@
+---
+title: Page Not Found
+---
+
+Sorry, this page doesn't exist. Use the navigation to find what you're looking for.