@ryanreh99/skills-sync 1.0.0

package/dist/lib/init.js

@@ -0,0 +1,292 @@
+import fs from "fs-extra";
+import path from "node:path";
+import {
+  ASSETS_ROOT,
+  LOCAL_OVERRIDES_ROOT,
+  SKILLS_SYNC_HOME,
+  logInfo,
+  logWarn,
+  writeJsonFile,
+  writeJsonFileIfMissing
+} from "./core.js";
+
+const DEFAULT_PROFILE_NAME = "personal";
+
+function resolveProfileName(rawProfile) {
+  if (typeof rawProfile !== "string") {
+    return DEFAULT_PROFILE_NAME;
+  }
+  const normalized = rawProfile.trim();
+  return normalized.length > 0 ? normalized : DEFAULT_PROFILE_NAME;
+}
+
+function getScaffoldFiles(localRoot, profileName) {
+  const profilesDir = path.join(localRoot, "profiles");
+  const packRoot = path.join(localRoot, "packs", profileName);
+  const mcpDir = path.join(packRoot, "mcp");
+  const skillsDir = path.join(packRoot, "skills");
+  const manifestsDir = path.join(localRoot, "manifests");
+  const stateDir = path.join(localRoot, "state");
+
+  return [
+    {
+      path: path.join(localRoot, "README.md"),
+      value: [
+        "# workspace",
+        "",
+        "Machine-local config for skills-sync.",
+        "",
+        "Edit these files:",
+        "- `packs/<name>/sources.json`",
+        "- `packs/<name>/mcp/servers.json`",
+        "- optional `profiles/<name>.json`",
+        "",
+        "Workflow:",
+        "1. Run `skills-sync build --profile <name>`",
+        "2. Run `skills-sync apply --profile <name>`",
+        ""
+      ].join("\n"),
+      type: "text"
+    },
+    {
+      path: path.join(profilesDir, `${profileName}.json`),
+      value: {
+        name: profileName,
+        packPath: `workspace/packs/${profileName}`
+      },
+      type: "json"
+    },
+    {
+      path: path.join(packRoot, "pack.json"),
+      value: {
+        name: profileName,
+        version: "0.0.0",
+        description: "",
+        maintainer: "",
+        tags: []
+      },
+      type: "json"
+    },
+    {
+      path: path.join(mcpDir, "servers.json"),
+      value: {
+        servers: {}
+      },
+      type: "json"
+    },
+    {
+      path: path.join(packRoot, "sources.json"),
+      value: {
+        imports: []
+      },
+      type: "json"
+    },
+    {
+      path: path.join(skillsDir, ".keep"),
+      value: "",
+      type: "text"
+    },
+    {
+      path: path.join(manifestsDir, ".keep"),
+      value: "",
+      type: "text"
+    },
+    {
+      path: path.join(stateDir, ".keep"),
+      value: "",
+      type: "text"
+    }
+  ];
+}
+
+async function ensureWorkspaceScaffold(localRoot, profileName) {
+  const files = getScaffoldFiles(localRoot, profileName);
+  let created = 0;
+  let skipped = 0;
+  for (const file of files) {
+    let wrote = false;
+    if (file.type === "json") {
+      wrote = await writeJsonFileIfMissing(file.path, file.value);
+    } else if (!(await fs.pathExists(file.path))) {
+      await fs.ensureDir(path.dirname(file.path));
+      await fs.writeFile(file.path, file.value, "utf8");
+      wrote = true;
+    }
+    if (wrote) {
+      created += 1;
+    } else {
+      skipped += 1;
+    }
+  }
+  return { created, skipped };
+}
+
+async function previewWorkspaceScaffold(localRoot, profileName) {
+  const files = getScaffoldFiles(localRoot, profileName);
+  let created = 0;
+  let skipped = 0;
+  for (const file of files) {
+    if (await fs.pathExists(file.path)) {
+      skipped += 1;
+    } else {
+      created += 1;
+    }
+  }
+  return { created, skipped };
+}
+
+async function inspectDefaultProfileUpdate({ force }) {
+  const configPath = path.join(LOCAL_OVERRIDES_ROOT, "config.json");
+  let existing = {};
+  let currentDefault = null;
+  if (await fs.pathExists(configPath)) {
+    existing = await fs.readJson(configPath);
+    if (typeof existing.defaultProfile === "string" && existing.defaultProfile.trim().length > 0) {
+      currentDefault = existing.defaultProfile.trim();
+    }
+  }
+
+  if (!force && currentDefault) {
+    return { shouldUpdate: false, currentDefault, existing, configPath };
+  }
+
+  return { shouldUpdate: true, currentDefault, existing, configPath };
+}
+
+async function ensureDefaultProfile({ profileName, force }) {
+  const inspection = await inspectDefaultProfileUpdate({ profileName, force });
+  if (!inspection.shouldUpdate) {
+    return { updated: false, defaultProfile: inspection.currentDefault };
+  }
+
+  await writeJsonFile(inspection.configPath, { ...inspection.existing, defaultProfile: profileName });
+  return { updated: true, defaultProfile: profileName, previousDefault: inspection.currentDefault };
+}
+
+async function previewDefaultProfile({ profileName, force }) {
+  const inspection = await inspectDefaultProfileUpdate({ profileName, force });
+  if (!inspection.shouldUpdate) {
+    return { updated: false, defaultProfile: inspection.currentDefault };
+  }
+  return {
+    updated: true,
+    defaultProfile: profileName,
+    previousDefault: inspection.currentDefault
+  };
+}
+
+export async function cmdInit({ seed = false, dryRun = false, profile = null } = {}) {
+  const selectedProfile = resolveProfileName(profile);
+  const profileWasExplicit = typeof profile === "string" && profile.trim().length > 0;
+
+  if (seed) {
+    const seedRoot = path.join(ASSETS_ROOT, "seed");
+    const localRoot = LOCAL_OVERRIDES_ROOT;
+    const backupPath = path.join(SKILLS_SYNC_HOME, "workspace.backup");
+    if (!(await fs.pathExists(seedRoot))) {
+      throw new Error("Seed content was not found.");
+    }
+
+    if (dryRun) {
+      const hasWorkspace = await fs.pathExists(localRoot);
+      const existingEntries = hasWorkspace ? await fs.readdir(localRoot) : [];
+      const defaultProfileResult = await previewDefaultProfile({
+        profileName: selectedProfile,
+        force: profileWasExplicit
+      });
+
+      logInfo(`Dry-run init --seed for profile '${selectedProfile}' complete. No files were modified.`);
+      if (existingEntries.length > 0) {
+        logInfo("Existing workspace would be backed up.");
+      } else {
+        logInfo("Seed content would be copied to workspace.");
+      }
+      if (defaultProfileResult.updated) {
+        logInfo(`Would set default profile to '${defaultProfileResult.defaultProfile}'.`);
+      } else {
+        logInfo(`Default profile would remain '${defaultProfileResult.defaultProfile}'.`);
+      }
+      return {
+        dryRun: true,
+        seed: true,
+        profile: selectedProfile
+      };
+    }
+
+    if (await fs.pathExists(localRoot)) {
+      const entries = await fs.readdir(localRoot);
+      if (entries.length > 0) {
+        await fs.remove(backupPath);
+        await fs.move(localRoot, backupPath);
+        logWarn("Backed up existing workspace.");
+      } else {
+        await fs.remove(localRoot);
+      }
+    }
+    await fs.copy(seedRoot, localRoot, { overwrite: true, errorOnExist: false });
+    const scaffold = await ensureWorkspaceScaffold(localRoot, selectedProfile);
+    const defaultProfileResult = await ensureDefaultProfile({
+      profileName: selectedProfile,
+      force: profileWasExplicit
+    });
+    logInfo(`Initialized workspace from seed for profile '${selectedProfile}'.`);
+    if (scaffold.created > 0) {
+      logInfo(
+        `Created ${scaffold.created} additional workspace files for profile '${selectedProfile}', skipped ${scaffold.skipped}.`
+      );
+    }
+    if (defaultProfileResult.updated) {
+      logInfo(`Default profile set to '${defaultProfileResult.defaultProfile}'.`);
+    }
+    process.stdout.write("\n");
+    process.stdout.write("Next steps:\n");
+    process.stdout.write(`  1) Current profile: '${selectedProfile}'\n`);
+    process.stdout.write("  2) Run: skills-sync build\n");
+    process.stdout.write("  3) Run: skills-sync apply\n");
+    process.stdout.write("  4) Run: skills-sync doctor\n");
+    return;
+  }
+
+  const localRoot = LOCAL_OVERRIDES_ROOT;
+  if (dryRun) {
+    const scaffold = await previewWorkspaceScaffold(localRoot, selectedProfile);
+    const defaultProfileResult = await previewDefaultProfile({
+      profileName: selectedProfile,
+      force: profileWasExplicit
+    });
+
+    logInfo(`Dry-run init for profile '${selectedProfile}' complete. No files were modified.`);
+    logInfo(`Would create ${scaffold.created} files, skip ${scaffold.skipped} existing files.`);
+    if (defaultProfileResult.updated) {
+      logInfo(`Would set default profile to '${defaultProfileResult.defaultProfile}'.`);
+    } else {
+      logInfo(`Default profile would remain '${defaultProfileResult.defaultProfile}'.`);
+    }
+    return {
+      dryRun: true,
+      seed: false,
+      profile: selectedProfile,
+      created: scaffold.created,
+      skipped: scaffold.skipped
+    };
+  }
+
+  const { created, skipped } = await ensureWorkspaceScaffold(localRoot, selectedProfile);
+  const defaultProfileResult = await ensureDefaultProfile({
+    profileName: selectedProfile,
+    force: profileWasExplicit
+  });
+
+  logInfo(`Initialized workspace for profile '${selectedProfile}'.`);
+  logInfo(`Created ${created} files for profile '${selectedProfile}', skipped ${skipped} existing files.`);
+  if (defaultProfileResult.updated) {
+    logInfo(`Default profile set to '${defaultProfileResult.defaultProfile}'.`);
+  } else {
+    logInfo(`Default profile remains '${defaultProfileResult.defaultProfile}'.`);
+  }
+  process.stdout.write("\n");
+  process.stdout.write("Next steps:\n");
+  process.stdout.write(`  1) Run: skills-sync build --profile ${selectedProfile}\n`);
+  process.stdout.write(`  2) Run: skills-sync apply --profile ${selectedProfile}\n`);
+  process.stdout.write("  3) Run: skills-sync doctor\n");
+}

package/dist/lib/inventory.js

@@ -0,0 +1,235 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { collectLocalSkillEntries } from "./bundle.js";
+import {
+  LOCAL_OVERRIDES_ROOT,
+  SCHEMAS,
+  assertJsonFileMatchesSchema,
+  isInsidePath
+} from "./core.js";
+import {
+  listAvailableProfiles,
+  loadPackSources,
+  readDefaultProfile,
+  resolvePack,
+  resolveProfile
+} from "./config.js";
+import { collectSourcePlanning, loadUpstreamsConfig } from "./upstreams.js";
+
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function sortStrings(values) {
+  return [...values].sort((left, right) => left.localeCompare(right));
+}
+
+function formatEnvAssignment(key, value) {
+  const text = String(value ?? "");
+  const quoted = text.length === 0 || /[\s,]/.test(text);
+  return `${key}=${quoted ? JSON.stringify(text) : text}`;
+}
+
+function inferProfileSource(profilePath) {
+  return isInsidePath(LOCAL_OVERRIDES_ROOT, profilePath) ? "local" : "seed";
+}
+
+function formatSkillsBlock(inventory) {
+  const lines = [];
+  lines.push(`Skills (${inventory.skills.total} total)`);
+  lines.push(`  Local (${inventory.skills.local.length})`);
+  if (inventory.skills.local.length === 0) {
+    lines.push("    (none)");
+  } else {
+    for (const item of inventory.skills.local) {
+      lines.push(`    ${item.name}`);
+    }
+  }
+
+  lines.push(`  Imported (${inventory.skills.imports.length})`);
+  if (inventory.skills.imports.length === 0) {
+    lines.push("    (none)");
+  } else {
+    for (const item of inventory.skills.imports) {
+      lines.push(
+        `    ${item.upstream}@${item.ref}  ${item.repoPath} -> ${item.destRelative}`
+      );
+    }
+  }
+  return lines;
+}
+
+function formatMcpBlock(inventory) {
+  const lines = [];
+  lines.push(`MCP Servers (${inventory.mcp.total})`);
+  if (inventory.mcp.servers.length === 0) {
+    lines.push("  (none)");
+    return lines;
+  }
+  for (const server of inventory.mcp.servers) {
+    if (typeof server.url === "string" && server.url.length > 0) {
+      lines.push(`  ${server.name}\t${server.url}`);
+      continue;
+    }
+    const args = server.args.length > 0 ? ` ${server.args.join(" ")}` : "";
+    const envEntries = sortStrings(Object.keys(server.env ?? {})).map((key) =>
+      formatEnvAssignment(key, server.env[key])
+    );
+    const env = envEntries.length > 0 ? ` [env:${envEntries.join(", ")}]` : "";
+    lines.push(`  ${server.name}\t${server.command}${args}${env}`);
+  }
+  return lines;
+}
+
+function profileText(inventory) {
+  const lines = [`Profile: ${inventory.profile.name} (${inventory.profile.source})`];
+  lines.push(...formatSkillsBlock(inventory));
+  lines.push(...formatMcpBlock(inventory));
+  return lines.join("\n");
+}
+
+export async function buildProfileInventory(profileName) {
+  const normalizedProfile = normalizeOptionalText(profileName);
+  if (!normalizedProfile) {
+    throw new Error("Profile name is required.");
+  }
+
+  const { profilePath, profile } = await resolveProfile(normalizedProfile);
+  const packRoot = await resolvePack(profile);
+
+  const { sources } = await loadPackSources(packRoot);
+  const upstreams = await loadUpstreamsConfig();
+  const planning = collectSourcePlanning(sources, upstreams.byId);
+
+  const localSkills = (await collectLocalSkillEntries(packRoot)).map((entry) => ({
+    name: entry.destRelative
+  }));
+  localSkills.sort((left, right) => left.name.localeCompare(right.name));
+
+  const imports = planning.skillImports
+    .map((entry) => ({
+      upstream: entry.upstreamId,
+      ref: entry.ref,
+      repoPath: entry.repoPath,
+      destRelative: entry.destRelative
+    }))
+    .sort((left, right) => {
+      const leftKey = `${left.upstream}::${left.ref}::${left.repoPath}::${left.destRelative}`;
+      const rightKey = `${right.upstream}::${right.ref}::${right.repoPath}::${right.destRelative}`;
+      return leftKey.localeCompare(rightKey);
+    });
+
+  const mcpPath = path.join(packRoot, "mcp", "servers.json");
+  const mcpDoc = (await fs.pathExists(mcpPath))
+    ? await assertJsonFileMatchesSchema(mcpPath, SCHEMAS.mcpServers)
+    : { servers: {} };
+  const mcpServers = sortStrings(Object.keys(mcpDoc.servers ?? {})).map((name) => {
+    const server = mcpDoc.servers[name] ?? {};
+    const url = typeof server.url === "string" && server.url.trim().length > 0 ? server.url.trim() : null;
+    const env = {};
+    if (server.env && typeof server.env === "object" && !Array.isArray(server.env)) {
+      for (const key of sortStrings(Object.keys(server.env))) {
+        env[key] = String(server.env[key]);
+      }
+    }
+    if (url) {
+      return {
+        name,
+        url
+      };
+    }
+    return {
+      name,
+      command: server.command,
+      args: Array.isArray(server.args) ? [...server.args] : [],
+      env
+    };
+  });
+
+  return {
+    profile: {
+      name: normalizedProfile,
+      source: inferProfileSource(profilePath)
+    },
+    skills: {
+      total: localSkills.length + imports.length,
+      local: localSkills,
+      imports
+    },
+    mcp: {
+      total: mcpServers.length,
+      servers: mcpServers
+    }
+  };
+}
+
+export async function cmdShowProfileInventory({ profile, format }) {
+  const explicitProfile = normalizeOptionalText(profile);
+  const resolvedProfile = explicitProfile ?? await readDefaultProfile();
+  if (!resolvedProfile) {
+    throw new Error(
+      "Profile is required. Provide --profile <name> or set a default with 'skills-sync use <name>'."
+    );
+  }
+
+  const inventory = await buildProfileInventory(resolvedProfile);
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify(inventory, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${profileText(inventory)}\n`);
+}
+
+export async function cmdListEverything({ format }) {
+  const profiles = await listAvailableProfiles();
+  if (profiles.length === 0) {
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify({ profiles: [] }, null, 2)}\n`);
+    } else {
+      process.stdout.write("No profiles found.\n");
+    }
+    return;
+  }
+
+  const results = [];
+  for (const item of profiles) {
+    try {
+      const inventory = await buildProfileInventory(item.name);
+      results.push({
+        profile: item.name,
+        source: item.source,
+        inventory
+      });
+    } catch (error) {
+      results.push({
+        profile: item.name,
+        source: item.source,
+        error: error.message
+      });
+    }
+  }
+
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify({ profiles: results }, null, 2)}\n`);
+    return;
+  }
+
+  for (let index = 0; index < results.length; index += 1) {
+    const item = results[index];
+    if (item.error) {
+      process.stdout.write(`Profile: ${item.profile} (${item.source})\n`);
+      process.stdout.write(`Error: ${item.error}\n`);
+    } else {
+      process.stdout.write(profileText(item.inventory));
+    }
+    if (index < results.length - 1) {
+      process.stdout.write("\n\n");
+    } else {
+      process.stdout.write("\n");
+    }
+  }
+}