destinotes-skills 0.2.0 → 0.3.1

package/README.md

@@ -19,7 +19,7 @@ This runs an **interactive setup** that walks you through:
 - Which agents to install to (Cursor, Claude Code)
 - Project-level vs global skill install
 
-Settings are saved to `./destinotes/destinotes.config.json`. Skills are copied into `.cursor/skills/` and/or `.claude/skills/`.
+Settings are saved to `./destinotes/destinotes.config.json`. On first run, setup **scans for existing `destinotes` folders** (root, `docs/`, `wiki/`, etc.). If one is found, you can confirm it and optionally **move everything to `./destinotes/`**.
 
 ### Non-interactive / CI
 

package/bin/install.mjs

@@ -87,6 +87,8 @@ Options:
   -h, --help            Show this help
 
 Interactive setup configures:
+  - Existing destinotes folder discovery (root, docs/, wiki/, etc.)
+  - Optional migration to ./destinotes/
   - Project name
   - Repository URL (auto-detected from git remote when possible)
   - Default branch

package/bin/lib/config.mjs

@@ -1,5 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import {
+  CANONICAL_DOCS_DIR,
+  discoverDestinotesFolders,
+  findConfigInDiscoveredFolders,
+} from "./discover.mjs";
 
 export const CONFIG_VERSION = 1;
 export const CONFIG_FILENAME = "destinotes.config.json";
@@ -8,14 +13,28 @@ export function getConfigPath(cwd, docsDir) {
   return join(cwd, docsDir, CONFIG_FILENAME);
 }
 
-export function readConfig(cwd, docsDir = "destinotes") {
-  const configPath = getConfigPath(cwd, docsDir);
-  if (!existsSync(configPath)) {
+export function readConfig(cwd, docsDir) {
+  if (docsDir) {
+    const configPath = getConfigPath(cwd, docsDir);
+    if (!existsSync(configPath)) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+
+  const located = findConfigInDiscoveredFolders(cwd);
+  if (!located) {
     return null;
   }
 
   try {
-    return JSON.parse(readFileSync(configPath, "utf8"));
+    const config = JSON.parse(readFileSync(located.configPath, "utf8"));
+    return { ...config, docsDir: config.docsDir ?? located.folder };
   } catch {
     return null;
   }

package/bin/lib/discover.mjs

@@ -0,0 +1,88 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+export const CANONICAL_DOCS_DIR = "destinotes";
+
+/** Relative paths (from project root) where a `destinotes` folder is commonly placed. */
+const COMMON_DESTINOTES_PATHS = [
+  "destinotes",
+  "docs/destinotes",
+  "doc/destinotes",
+  "documentation/destinotes",
+  "wiki/destinotes",
+  "content/destinotes",
+  "knowledge/destinotes",
+  "notes/destinotes",
+  "internal/destinotes",
+  ".destinotes",
+];
+
+function countEntries(dirPath) {
+  let files = 0;
+  let dirs = 0;
+
+  for (const entry of readdirSync(dirPath)) {
+    const fullPath = join(dirPath, entry);
+    if (statSync(fullPath).isDirectory()) {
+      dirs += 1;
+    } else {
+      files += 1;
+    }
+  }
+
+  return { files, dirs, total: files + dirs };
+}
+
+function describeFolder(relativePath, counts) {
+  const parts = [];
+  if (counts.files > 0) {
+    parts.push(`${counts.files} file${counts.files === 1 ? "" : "s"}`);
+  }
+  if (counts.dirs > 0) {
+    parts.push(`${counts.dirs} folder${counts.dirs === 1 ? "" : "s"}`);
+  }
+  const summary = parts.length > 0 ? parts.join(", ") : "empty";
+  return { relative: relativePath, ...counts, summary };
+}
+
+export function discoverDestinotesFolders(cwd) {
+  const found = [];
+
+  for (const relativePath of COMMON_DESTINOTES_PATHS) {
+    const absolutePath = join(cwd, relativePath);
+    if (!existsSync(absolutePath) || !statSync(absolutePath).isDirectory()) {
+      continue;
+    }
+
+    found.push(describeFolder(relativePath, countEntries(absolutePath)));
+  }
+
+  return found.sort((a, b) => {
+    if (a.relative === CANONICAL_DOCS_DIR) {
+      return -1;
+    }
+    if (b.relative === CANONICAL_DOCS_DIR) {
+      return 1;
+    }
+    return a.relative.localeCompare(b.relative);
+  });
+}
+
+export function findConfigInDiscoveredFolders(cwd, folders = discoverDestinotesFolders(cwd)) {
+  for (const folder of folders) {
+    const configPath = join(cwd, folder.relative, "destinotes.config.json");
+    if (existsSync(configPath)) {
+      return { folder: folder.relative, configPath };
+    }
+  }
+
+  return null;
+}
+
+export function isCanonicalDocsDir(relativePath) {
+  return relativePath === CANONICAL_DOCS_DIR;
+}
+
+export function formatFolderOption(folder) {
+  return `./${folder.relative}/ (${folder.summary})`;
+}

package/bin/lib/migrate.mjs

@@ -0,0 +1,95 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { join } from "node:path";
+import { CANONICAL_DOCS_DIR } from "./discover.mjs";
+
+function isEmptyDir(dirPath) {
+  return readdirSync(dirPath).length === 0;
+}
+
+function removeEmptyDirs(dirPath) {
+  if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) {
+    return;
+  }
+
+  for (const entry of readdirSync(dirPath)) {
+    const child = join(dirPath, entry);
+    if (statSync(child).isDirectory()) {
+      removeEmptyDirs(child);
+    }
+  }
+
+  if (isEmptyDir(dirPath)) {
+    rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+
+function moveEntry(sourcePath, destPath) {
+  try {
+    renameSync(sourcePath, destPath);
+  } catch {
+    cpSync(sourcePath, destPath, { recursive: true, force: true });
+    rmSync(sourcePath, { recursive: true, force: true });
+  }
+}
+
+export function migrateToCanonical(cwd, sourceRelative) {
+  if (sourceRelative === CANONICAL_DOCS_DIR) {
+    return {
+      migrated: false,
+      source: sourceRelative,
+      dest: CANONICAL_DOCS_DIR,
+      moved: [],
+      skipped: [],
+    };
+  }
+
+  const sourcePath = join(cwd, sourceRelative);
+  const destPath = join(cwd, CANONICAL_DOCS_DIR);
+
+  if (!existsSync(sourcePath)) {
+    throw new Error(`Source folder not found: ./${sourceRelative}/`);
+  }
+
+  mkdirSync(destPath, { recursive: true });
+
+  const moved = [];
+  const skipped = [];
+
+  for (const entry of readdirSync(sourcePath)) {
+    const from = join(sourcePath, entry);
+    const to = join(destPath, entry);
+
+    if (existsSync(to)) {
+      skipped.push(entry);
+      continue;
+    }
+
+    const stat = statSync(from);
+    if (stat.isDirectory()) {
+      cpSync(from, to, { recursive: true });
+      rmSync(from, { recursive: true, force: true });
+    } else {
+      moveEntry(from, to);
+    }
+
+    moved.push(entry);
+  }
+
+  removeEmptyDirs(sourcePath);
+
+  return {
+    migrated: true,
+    source: sourceRelative,
+    dest: CANONICAL_DOCS_DIR,
+    moved,
+    skipped,
+  };
+}

package/bin/lib/prompt.mjs

@@ -22,6 +22,34 @@ export async function confirm(rl, question, defaultYes = true) {
   return answer === "y" || answer === "yes";
 }
 
+export async function chooseFromList(rl, prompt, options, { allowSkip = true } = {}) {
+  if (options.length === 0) {
+    return null;
+  }
+
+  console.log(`\n${prompt}`);
+  options.forEach((option, index) => {
+    console.log(`  ${index + 1}. ${option.label}`);
+  });
+
+  if (allowSkip) {
+    console.log("  (press Enter to skip)");
+  }
+
+  const answer = (await rl.question("Choice: ")).trim();
+  if (!answer) {
+    return allowSkip ? null : options[0]?.value ?? null;
+  }
+
+  const index = Number.parseInt(answer, 10) - 1;
+  if (Number.isNaN(index) || index < 0 || index >= options.length) {
+    console.log("Invalid choice — skipping.");
+    return null;
+  }
+
+  return options[index].value;
+}
+
 export async function chooseAgents(rl, detected, labels) {
   const selected = [];
 

package/bin/setup.mjs

@@ -4,13 +4,96 @@ import {
   readConfig,
   scaffoldDocs,
 } from "./lib/config.mjs";
+import {
+  CANONICAL_DOCS_DIR,
+  discoverDestinotesFolders,
+  formatFolderOption,
+  isCanonicalDocsDir,
+} from "./lib/discover.mjs";
+import { migrateToCanonical } from "./lib/migrate.mjs";
 import {
   ask,
   chooseAgents,
+  chooseFromList,
   confirm,
   createPrompter,
 } from "./lib/prompt.mjs";
 
+async function resolveDocsFolder(rl, cwd, existing) {
+  const discovered = discoverDestinotesFolders(cwd);
+  let docsDirDefault = existing?.docsDir ?? CANONICAL_DOCS_DIR;
+  let migrationResult = null;
+
+  if (discovered.length === 0) {
+    return { docsDirDefault, migrationResult };
+  }
+
+  console.log("\nExisting Destinotes folders found:");
+
+  let selectedRelative = null;
+
+  if (discovered.length === 1) {
+    const folder = discovered[0];
+    console.log(`  · ${formatFolderOption(folder)}`);
+
+    const isDocsFolder = await confirm(
+      rl,
+      `Is ./${folder.relative}/ your Destinotes docs folder?`,
+      true,
+    );
+
+    if (isDocsFolder) {
+      selectedRelative = folder.relative;
+    }
+  } else {
+    selectedRelative = await chooseFromList(
+      rl,
+      "Which folder holds your Destinotes docs?",
+      discovered.map((folder) => ({
+        label: formatFolderOption(folder),
+        value: folder.relative,
+      })),
+    );
+  }
+
+  if (!selectedRelative) {
+    return { docsDirDefault, migrationResult };
+  }
+
+  if (isCanonicalDocsDir(selectedRelative)) {
+    docsDirDefault = CANONICAL_DOCS_DIR;
+    return { docsDirDefault, migrationResult };
+  }
+
+  const shouldMigrate = await confirm(
+    rl,
+    `Move everything from ./${selectedRelative}/ to ./${CANONICAL_DOCS_DIR}/?`,
+    true,
+  );
+
+  if (shouldMigrate) {
+    migrationResult = migrateToCanonical(cwd, selectedRelative);
+    docsDirDefault = CANONICAL_DOCS_DIR;
+
+    if (migrationResult.moved.length > 0) {
+      console.log(
+        `✓ Moved ${migrationResult.moved.length} item(s) to ./${CANONICAL_DOCS_DIR}/`,
+      );
+    }
+
+    if (migrationResult.skipped.length > 0) {
+      console.log(
+        `  Skipped (already exists in ./${CANONICAL_DOCS_DIR}/): ${migrationResult.skipped.join(", ")}`,
+      );
+    }
+  } else {
+    docsDirDefault = selectedRelative;
+    console.log(`Using ./${selectedRelative}/ as the docs folder.`);
+  }
+
+  return { docsDirDefault, migrationResult };
+}
+
 export async function runSetup({
   cwd,
   global = false,
@@ -23,16 +106,24 @@ export async function runSetup({
   const existing = readConfig(cwd);
 
   if (yes) {
+    const discovered = discoverDestinotesFolders(cwd);
+    const docsDir =
+      existing?.docsDir ??
+      discovered.find((folder) => isCanonicalDocsDir(folder.relative))?.relative ??
+      discovered[0]?.relative ??
+      CANONICAL_DOCS_DIR;
+
     return {
       version: CONFIG_VERSION,
       projectName: existing?.projectName ?? detectProjectName(cwd),
       description: existing?.description ?? "",
       repositoryUrl: existing?.repositoryUrl ?? git.repositoryUrl ?? "",
       defaultBranch: existing?.defaultBranch ?? git.defaultBranch,
-      docsDir: existing?.docsDir ?? "destinotes",
+      docsDir,
       installedAt: new Date().toISOString(),
       global,
       agents: agents ?? existing?.agents ?? detectedAgents,
+      migration: null,
     };
   }
 
@@ -59,10 +150,17 @@ export async function runSetup({
           ...existing,
           global: existing.global ?? global,
           agents: selectedAgents,
+          migration: null,
         };
       }
     }
 
+    const { docsDirDefault, migrationResult } = await resolveDocsFolder(
+      rl,
+      cwd,
+      existing,
+    );
+
     const projectName = await ask(
       rl,
       "Project name",
@@ -84,7 +182,7 @@ export async function runSetup({
     const docsDir = await ask(
       rl,
       "Docs output folder (relative to project root)",
-      existing?.docsDir ?? "destinotes",
+      docsDirDefault,
     );
 
     const description = await ask(
@@ -114,6 +212,7 @@ export async function runSetup({
       installedAt: new Date().toISOString(),
       global,
       agents: selectedAgents,
+      migration: migrationResult,
     };
 
     console.log("\nSetup summary:");
@@ -121,6 +220,11 @@ export async function runSetup({
     console.log(`  Repository:  ${config.repositoryUrl || "(none)"}`);
     console.log(`  Branch:      ${config.defaultBranch}`);
     console.log(`  Docs folder: ./${config.docsDir}/`);
+    if (migrationResult?.migrated) {
+      console.log(
+        `  Migration:   ./${migrationResult.source}/ → ./${migrationResult.dest}/`,
+      );
+    }
     console.log(
       `  Agents:      ${selectedAgents.map((id) => agentLabels[id]).join(", ")}`,
     );
@@ -143,7 +247,9 @@ export function finalizeProjectFiles(cwd, config, existingConfig) {
     return null;
   }
 
-  return scaffoldDocs(cwd, config, {
-    overwriteReadme: Boolean(existingConfig),
+  const { migration: _migration, ...persistedConfig } = config;
+
+  return scaffoldDocs(cwd, persistedConfig, {
+    overwriteReadme: Boolean(existingConfig) || Boolean(config.migration?.migrated),
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "destinotes-skills",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Agent skills that generate repository documentation under ./destinotes/",
   "license": "MIT",
   "type": "module",