knowns 0.10.1 → 0.10.2

package/dist/mcp/server.js

@@ -10289,17 +10289,39 @@ var require_gray_matter = __commonJS({
 });
 
 // src/import/config.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join7 } from "node:path";
 function getKnownsDir(projectRoot) {
   return join7(projectRoot, ".knowns");
 }
+function getConfigPath(projectRoot) {
+  return join7(getKnownsDir(projectRoot), CONFIG_FILE);
+}
 function getImportsDir(projectRoot) {
   return join7(getKnownsDir(projectRoot), IMPORTS_DIR);
 }
-var IMPORTS_DIR;
+async function readConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (!existsSync4(configPath)) {
+    return {};
+  }
+  try {
+    const content = await readFile3(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function getImportConfigs(projectRoot) {
+  const config2 = await readConfig(projectRoot);
+  return config2.imports || [];
+}
+var CONFIG_FILE, IMPORTS_DIR;
 var init_config = __esm({
   "src/import/config.ts"() {
     "use strict";
+    CONFIG_FILE = "config.json";
     IMPORTS_DIR = "imports";
   }
 });
@@ -28631,8 +28653,8 @@ var require_prompts3 = __commonJS({
 });
 
 // src/mcp/server.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { readFile as readFile8 } from "node:fs/promises";
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile9 } from "node:fs/promises";
 import { join as join18 } from "node:path";
 
 // node_modules/zod/v3/helpers/util.js
@@ -51220,8 +51242,8 @@ async function handleGetBoard(fileStore2) {
 }
 
 // src/mcp/handlers/doc.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile3, readdir as readdir5, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { mkdir as mkdir7, readFile as readFile4, readdir as readdir5, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join13 } from "node:path";
 
 // src/utils/markdown-toc.ts
@@ -51398,7 +51420,7 @@ var ImportError = class extends Error {
 init_config();
 
 // src/import/validator.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 var KNOWNS_DIR = ".knowns";
@@ -51406,7 +51428,7 @@ var TEMPLATES_DIR = "templates";
 var DOCS_DIR = "docs";
 async function validateKnownsDir(dir) {
   const knownsPath = join8(dir, KNOWNS_DIR);
-  if (!existsSync4(knownsPath)) {
+  if (!existsSync5(knownsPath)) {
     return {
       valid: false,
       error: "Source does not contain .knowns/ directory",
@@ -51415,8 +51437,8 @@ async function validateKnownsDir(dir) {
   }
   const templatesPath = join8(knownsPath, TEMPLATES_DIR);
   const docsPath = join8(knownsPath, DOCS_DIR);
-  const hasTemplates = existsSync4(templatesPath);
-  const hasDocs = existsSync4(docsPath);
+  const hasTemplates = existsSync5(templatesPath);
+  const hasDocs = existsSync5(docsPath);
   if (!hasTemplates && !hasDocs) {
     return {
       valid: false,
@@ -51477,7 +51499,7 @@ var ImportProvider = class {
 
 // src/import/providers/git.ts
 import { execSync, spawnSync } from "node:child_process";
-import { mkdir as mkdir3 } from "node:fs/promises";
+import { mkdir as mkdir4 } from "node:fs/promises";
 var KNOWNS_DIR2 = ".knowns";
 function getGitInfo() {
   try {
@@ -51548,7 +51570,7 @@ var GitProvider = class extends ImportProvider {
       throw new ImportError("Git is not installed", "GIT_ERROR" /* GIT_ERROR */, "Install git first");
     }
     const tempDir = this.getTempDir();
-    await mkdir3(tempDir, { recursive: true });
+    await mkdir4(tempDir, { recursive: true });
     const ref = options2?.ref || "HEAD";
     try {
       if (this.gitInfo.supportsSparse) {
@@ -51625,8 +51647,8 @@ var gitProvider = new GitProvider();
 
 // src/import/providers/npm.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir4, readdir as readdir3, rename as rename2, rm as rm2 } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+import { mkdir as mkdir5, readdir as readdir3, rename as rename2, rm as rm2 } from "node:fs/promises";
 import { join as join10 } from "node:path";
 function isNpmAvailable() {
   try {
@@ -51688,7 +51710,7 @@ var NpmProvider = class extends ImportProvider {
       throw new ImportError("npm is not installed", "NPM_ERROR" /* NPM_ERROR */, "Install Node.js/npm first");
     }
     const tempDir = this.getTempDir();
-    await mkdir4(tempDir, { recursive: true });
+    await mkdir5(tempDir, { recursive: true });
     const packageSpec = options2?.version ? `${source}@${options2.version}` : source;
     try {
       const packResult = spawnSync2("npm", ["pack", packageSpec, "--pack-destination", tempDir], {
@@ -51712,7 +51734,7 @@ var NpmProvider = class extends ImportProvider {
         throw new Error(extractResult.stderr || "tar extraction failed");
       }
       const packageDir = join10(tempDir, "package");
-      if (!existsSync5(packageDir)) {
+      if (!existsSync6(packageDir)) {
         throw new Error("Extracted package directory not found");
       }
       const extractedDir = this.getTempDir();
@@ -51743,9 +51765,9 @@ var NpmProvider = class extends ImportProvider {
     const metadata = {};
     try {
       const packageJsonPath = join10(tempDir, "package.json");
-      if (existsSync5(packageJsonPath)) {
-        const { readFile: readFile9 } = await import("node:fs/promises");
-        const content = await readFile9(packageJsonPath, "utf-8");
+      if (existsSync6(packageJsonPath)) {
+        const { readFile: readFile10 } = await import("node:fs/promises");
+        const content = await readFile10(packageJsonPath, "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.version) {
           metadata.version = pkg.version;
@@ -51762,8 +51784,8 @@ var NpmProvider = class extends ImportProvider {
 var npmProvider = new NpmProvider();
 
 // src/import/providers/local.ts
-import { existsSync as existsSync6, statSync } from "node:fs";
-import { cp, mkdir as mkdir5, readlink, symlink } from "node:fs/promises";
+import { existsSync as existsSync7, statSync } from "node:fs";
+import { cp, mkdir as mkdir6, readlink, symlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join as join11, resolve } from "node:path";
 var KNOWNS_DIR3 = ".knowns";
@@ -51781,7 +51803,7 @@ var LocalProvider = class extends ImportProvider {
   type = "local";
   async validate(source, _options) {
     const resolvedPath = resolvePath(source);
-    if (!existsSync6(resolvedPath)) {
+    if (!existsSync7(resolvedPath)) {
       return {
         valid: false,
         error: `Path not found: ${source}`,
@@ -51798,7 +51820,7 @@ var LocalProvider = class extends ImportProvider {
     let knownsPath;
     if (resolvedPath.endsWith(KNOWNS_DIR3)) {
       knownsPath = resolvedPath;
-    } else if (existsSync6(join11(resolvedPath, KNOWNS_DIR3))) {
+    } else if (existsSync7(join11(resolvedPath, KNOWNS_DIR3))) {
       knownsPath = join11(resolvedPath, KNOWNS_DIR3);
     } else {
       return {
@@ -51812,7 +51834,7 @@ var LocalProvider = class extends ImportProvider {
   }
   async fetch(source, options2) {
     const resolvedPath = resolvePath(source);
-    if (!existsSync6(resolvedPath)) {
+    if (!existsSync7(resolvedPath)) {
       throw new ImportError(`Path not found: ${source}`, "SOURCE_NOT_FOUND" /* SOURCE_NOT_FOUND */);
     }
     let sourceKnowns;
@@ -51821,7 +51843,7 @@ var LocalProvider = class extends ImportProvider {
     } else {
       sourceKnowns = join11(resolvedPath, KNOWNS_DIR3);
     }
-    if (!existsSync6(sourceKnowns)) {
+    if (!existsSync7(sourceKnowns)) {
       throw new ImportError(
         "Source does not contain .knowns/ directory",
         "NO_KNOWNS_DIR" /* NO_KNOWNS_DIR */,
@@ -51837,7 +51859,7 @@ var LocalProvider = class extends ImportProvider {
       return sourceKnowns;
     }
     const tempDir = this.getTempDir();
-    await mkdir5(tempDir, { recursive: true });
+    await mkdir6(tempDir, { recursive: true });
     try {
       await cp(parentDir, tempDir, { recursive: true });
       return tempDir;
@@ -51857,12 +51879,12 @@ var LocalProvider = class extends ImportProvider {
    */
   async createSymlink(source, target) {
     const resolvedSource = resolvePath(source);
-    if (existsSync6(target)) {
+    if (existsSync7(target)) {
       const { rm: rm3 } = await import("node:fs/promises");
       await rm3(target, { recursive: true, force: true });
     }
     const { dirname: dirname4 } = await import("node:path");
-    await mkdir5(dirname4(target), { recursive: true });
+    await mkdir6(dirname4(target), { recursive: true });
     await symlink(resolvedSource, target, "junction");
   }
   /**
@@ -51884,15 +51906,46 @@ init_config();
 
 // src/import/resolver.ts
 init_config();
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { readdir as readdir4 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var KNOWNS_DIR4 = ".knowns";
+var TEMPLATES_DIR2 = "templates";
 var DOCS_DIR2 = "docs";
+async function getTemplateDirectories(projectRoot) {
+  const results = [];
+  const localTemplates = join12(projectRoot, KNOWNS_DIR4, TEMPLATES_DIR2);
+  if (existsSync8(localTemplates)) {
+    results.push({
+      path: localTemplates,
+      source: "local",
+      isImported: false
+    });
+  }
+  const importsDir = getImportsDir(projectRoot);
+  if (existsSync8(importsDir)) {
+    try {
+      const entries = await readdir4(importsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const importedTemplates = join12(importsDir, entry.name, TEMPLATES_DIR2);
+        if (existsSync8(importedTemplates)) {
+          results.push({
+            path: importedTemplates,
+            source: entry.name,
+            isImported: true
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
 async function getDocDirectories(projectRoot) {
   const results = [];
   const localDocs = join12(projectRoot, KNOWNS_DIR4, DOCS_DIR2);
-  if (existsSync7(localDocs)) {
+  if (existsSync8(localDocs)) {
     results.push({
       path: localDocs,
       source: "local",
@@ -51900,13 +51953,13 @@ async function getDocDirectories(projectRoot) {
     });
   }
   const importsDir = getImportsDir(projectRoot);
-  if (existsSync7(importsDir)) {
+  if (existsSync8(importsDir)) {
     try {
       const entries = await readdir4(importsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const importedDocs = join12(importsDir, entry.name, DOCS_DIR2);
-        if (existsSync7(importedDocs)) {
+        if (existsSync8(importedDocs)) {
           results.push({
             path: importedDocs,
             source: entry.name,
@@ -51927,7 +51980,7 @@ async function parseImportPath(projectRoot, refPath) {
   const potentialImport = parts[0];
   const importsDir = getImportsDir(projectRoot);
   const importPath = join12(importsDir, potentialImport);
-  if (existsSync7(importPath)) {
+  if (existsSync8(importPath)) {
     return {
       importName: potentialImport,
       subPath: parts.slice(1).join("/")
@@ -51944,7 +51997,7 @@ async function resolveDocWithContext(projectRoot, docPath, context) {
   if (importName) {
     const importedDocs = join12(getImportsDir(projectRoot), importName, DOCS_DIR2);
     const fullPath = join12(importedDocs, normalizedSubPath);
-    if (existsSync7(fullPath)) {
+    if (existsSync8(fullPath)) {
       return {
         path: fullPath,
         source: importName,
@@ -51958,7 +52011,7 @@ async function resolveDocWithContext(projectRoot, docPath, context) {
     const contextDir = directories.find((d) => d.source === context && d.isImported);
     if (contextDir) {
       const fullPath = join12(contextDir.path, normalizedSubPath);
-      if (existsSync7(fullPath)) {
+      if (existsSync8(fullPath)) {
         return {
           path: fullPath,
           source: contextDir.source,
@@ -51971,7 +52024,7 @@ async function resolveDocWithContext(projectRoot, docPath, context) {
   const localDirs = directories.filter((d) => !d.isImported);
   for (const dir of importDirs) {
     const fullPath = join12(dir.path, normalizedSubPath);
-    if (existsSync7(fullPath)) {
+    if (existsSync8(fullPath)) {
       return {
         path: fullPath,
         source: dir.source,
@@ -51981,7 +52034,7 @@ async function resolveDocWithContext(projectRoot, docPath, context) {
   }
   for (const dir of localDirs) {
     const fullPath = join12(dir.path, normalizedSubPath);
-    if (existsSync7(fullPath)) {
+    if (existsSync8(fullPath)) {
       return {
         path: fullPath,
         source: dir.source,
@@ -51991,6 +52044,67 @@ async function resolveDocWithContext(projectRoot, docPath, context) {
   }
   return null;
 }
+async function listAllTemplates(projectRoot) {
+  const directories = await getTemplateDirectories(projectRoot);
+  const importConfigs = await getImportConfigs(projectRoot);
+  const sourceUrlMap = new Map(importConfigs.map((c) => [c.name, c.source]));
+  const results = [];
+  for (const dir of directories) {
+    try {
+      const entries = await readdir4(dir.path, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".")) continue;
+        const ref = dir.isImported ? `${dir.source}/${entry.name}` : entry.name;
+        results.push({
+          name: entry.name,
+          ref,
+          source: dir.source,
+          sourceUrl: dir.isImported ? sourceUrlMap.get(dir.source) : void 0,
+          path: join12(dir.path, entry.name),
+          isImported: dir.isImported
+        });
+      }
+    } catch {
+    }
+  }
+  return results.sort((a, b) => a.ref.localeCompare(b.ref));
+}
+async function listAllDocs(projectRoot) {
+  const directories = await getDocDirectories(projectRoot);
+  const importConfigs = await getImportConfigs(projectRoot);
+  const sourceUrlMap = new Map(importConfigs.map((c) => [c.name, c.source]));
+  const results = [];
+  async function scanDir(baseDir, relativePath, source, isImported) {
+    const currentDir = join12(baseDir, relativePath);
+    try {
+      const entries = await readdir4(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const entryRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          await scanDir(baseDir, entryRelPath, source, isImported);
+        } else if (entry.name.endsWith(".md")) {
+          const docPath = entryRelPath.replace(/\.md$/, "");
+          const ref = isImported ? `${source}/${docPath}` : docPath;
+          results.push({
+            name: docPath,
+            ref,
+            source,
+            sourceUrl: isImported ? sourceUrlMap.get(source) : void 0,
+            fullPath: join12(currentDir, entry.name),
+            isImported
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  for (const dir of directories) {
+    await scanDir(dir.path, "", dir.source, dir.isImported);
+  }
+  return results.sort((a, b) => a.ref.localeCompare(b.ref));
+}
 async function validateRefs(projectRoot, content, tasksDir) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
@@ -52019,7 +52133,7 @@ async function validateRefs(projectRoot, content, tasksDir) {
     let exists = false;
     if (tasksDir) {
       const taskPath = join12(tasksDir, `task-${taskId}.md`);
-      exists = existsSync7(taskPath);
+      exists = existsSync8(taskPath);
     }
     results.push({
       ref: `@task-${taskId}`,
@@ -52182,8 +52296,8 @@ var docTools = [
   }
 ];
 async function ensureDocsDir() {
-  if (!existsSync8(DOCS_DIR3)) {
-    await mkdir6(DOCS_DIR3, { recursive: true });
+  if (!existsSync9(DOCS_DIR3)) {
+    await mkdir7(DOCS_DIR3, { recursive: true });
   }
 }
 function titleToFilename(title) {
@@ -52191,7 +52305,7 @@ function titleToFilename(title) {
 }
 async function getAllMdFiles(dir, basePath = "") {
   const files = [];
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     return files;
   }
   const entries = await readdir5(dir, { withFileTypes: true });
@@ -52211,12 +52325,12 @@ async function resolveDocPath(name) {
   await ensureDocsDir();
   let filename = name.endsWith(".md") ? name : `${name}.md`;
   let filepath = join13(DOCS_DIR3, filename);
-  if (existsSync8(filepath)) {
+  if (existsSync9(filepath)) {
     return { filepath, filename };
   }
   filename = `${titleToFilename(name)}.md`;
   filepath = join13(DOCS_DIR3, filename);
-  if (existsSync8(filepath)) {
+  if (existsSync9(filepath)) {
     return { filepath, filename };
   }
   const allFiles = await getAllMdFiles(DOCS_DIR3);
@@ -52237,8 +52351,9 @@ async function resolveDocPath(name) {
 async function handleListDocs(args) {
   const input = listDocsSchema.parse(args);
   await ensureDocsDir();
-  const mdFiles = await getAllMdFiles(DOCS_DIR3);
-  if (mdFiles.length === 0) {
+  const projectRoot = process.cwd();
+  const allDocs = await listAllDocs(projectRoot);
+  if (allDocs.length === 0) {
     return successResponse({
       count: 0,
       docs: [],
@@ -52246,22 +52361,29 @@ async function handleListDocs(args) {
     });
   }
   const docs = [];
-  for (const file3 of mdFiles) {
-    const fileContent = await readFile3(join13(DOCS_DIR3, file3), "utf-8");
-    const { data, content } = (0, import_gray_matter3.default)(fileContent);
-    const metadata = data;
-    const stats = calculateDocStats(content);
-    if (input.tag && !metadata.tags?.includes(input.tag)) {
-      continue;
+  for (const doc of allDocs) {
+    try {
+      const fileContent = await readFile4(doc.fullPath, "utf-8");
+      const { data, content } = (0, import_gray_matter3.default)(fileContent);
+      const metadata = data;
+      const stats = calculateDocStats(content);
+      if (input.tag && !metadata.tags?.includes(input.tag)) {
+        continue;
+      }
+      docs.push({
+        path: doc.ref,
+        // Use full ref path (includes import prefix if imported)
+        title: metadata.title || doc.name,
+        description: metadata.description,
+        tags: metadata.tags,
+        tokens: stats.estimatedTokens,
+        updatedAt: metadata.updatedAt,
+        source: doc.source,
+        sourceUrl: doc.sourceUrl,
+        isImported: doc.isImported
+      });
+    } catch {
     }
-    docs.push({
-      path: file3.replace(/\.md$/, ""),
-      title: metadata.title || file3.replace(/\.md$/, ""),
-      description: metadata.description,
-      tags: metadata.tags,
-      tokens: stats.estimatedTokens,
-      updatedAt: metadata.updatedAt
-    });
   }
   return successResponse({
     count: docs.length,
@@ -52274,7 +52396,7 @@ async function handleGetDoc(args) {
   if (!resolved) {
     return errorResponse(`Documentation not found: ${input.path}`);
   }
-  const fileContent = await readFile3(resolved.filepath, "utf-8");
+  const fileContent = await readFile4(resolved.filepath, "utf-8");
   const { data, content } = (0, import_gray_matter3.default)(fileContent);
   const metadata = data;
   if (input.smart) {
@@ -52396,12 +52518,12 @@ async function handleCreateDoc(args) {
     const folderPath = input.folder.replace(/^\/|\/$/g, "");
     targetDir = join13(DOCS_DIR3, folderPath);
     relativePath = join13(folderPath, filename);
-    if (!existsSync8(targetDir)) {
-      await mkdir6(targetDir, { recursive: true });
+    if (!existsSync9(targetDir)) {
+      await mkdir7(targetDir, { recursive: true });
     }
   }
   const filepath = join13(targetDir, filename);
-  if (existsSync8(filepath)) {
+  if (existsSync9(filepath)) {
     return errorResponse(`Document already exists: ${relativePath}`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -52418,7 +52540,7 @@ async function handleCreateDoc(args) {
   }
   const initialContent = input.content || "# Content\n\nWrite your documentation here.";
   const fileContent = import_gray_matter3.default.stringify(initialContent, metadata);
-  await writeFile2(filepath, fileContent, "utf-8");
+  await writeFile3(filepath, fileContent, "utf-8");
   await notifyDocUpdate(relativePath);
   return successResponse({
     message: `Created documentation: ${relativePath}`,
@@ -52436,7 +52558,7 @@ async function handleUpdateDoc(args) {
   if (!resolved) {
     return errorResponse(`Documentation not found: ${input.path}`);
   }
-  const fileContent = await readFile3(resolved.filepath, "utf-8");
+  const fileContent = await readFile4(resolved.filepath, "utf-8");
   const { data, content } = (0, import_gray_matter3.default)(fileContent);
   const metadata = data;
   if (input.title) metadata.title = input.title;
@@ -52464,7 +52586,7 @@ async function handleUpdateDoc(args) {
 ${input.appendContent}`;
   }
   const newFileContent = import_gray_matter3.default.stringify(updatedContent, metadata);
-  await writeFile2(resolved.filepath, newFileContent, "utf-8");
+  await writeFile3(resolved.filepath, newFileContent, "utf-8");
   await notifyDocUpdate(resolved.filename);
   return successResponse({
     message: sectionUpdated ? `Updated section "${sectionUpdated}" in ${resolved.filename}` : `Updated documentation: ${resolved.filename}`,
@@ -52485,7 +52607,7 @@ async function handleSearchDocs(args) {
   const query = input.query.toLowerCase();
   const results = [];
   for (const file3 of mdFiles) {
-    const fileContent = await readFile3(join13(DOCS_DIR3, file3), "utf-8");
+    const fileContent = await readFile4(join13(DOCS_DIR3, file3), "utf-8");
     const { data, content } = (0, import_gray_matter3.default)(fileContent);
     const metadata = data;
     if (input.tag && !metadata.tags?.includes(input.tag)) {
@@ -52522,7 +52644,7 @@ async function handleSearchDocs(args) {
 }
 
 // src/codegen/renderer.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 var import_handlebars = __toESM(require_lib(), 1);
 
 // node_modules/change-case/dist/index.js
@@ -52719,7 +52841,7 @@ function renderString(template, context) {
   return compiled(context);
 }
 async function renderFile(templatePath, context) {
-  const content = await readFile4(templatePath, "utf-8");
+  const content = await readFile5(templatePath, "utf-8");
   return renderString(content, context);
 }
 function renderPath(pathPattern, context) {
@@ -52895,8 +53017,8 @@ async function handleGetGuideline(args) {
 }
 
 // src/mcp/handlers/template.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { mkdir as mkdir8, writeFile as writeFile4 } from "node:fs/promises";
+import { existsSync as existsSync12 } from "node:fs";
+import { mkdir as mkdir9, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 
 // src/codegen/schema.ts
@@ -52977,8 +53099,8 @@ function safeValidateTemplateConfig(data) {
 
 // src/codegen/parser.ts
 var import_yaml = __toESM(require_dist2(), 1);
-import { existsSync as existsSync9 } from "node:fs";
-import { readFile as readFile5, readdir as readdir6 } from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { readFile as readFile6, readdir as readdir6 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 var CONFIG_FILENAME = "_template.yaml";
 var TEMPLATE_EXTENSION = ".hbs";
@@ -52991,16 +53113,16 @@ var TemplateParseError = class extends Error {
   }
 };
 async function loadTemplate(templateDir) {
-  if (!existsSync9(templateDir)) {
+  if (!existsSync10(templateDir)) {
     throw new TemplateParseError(`Template directory not found: ${templateDir}`);
   }
   const configPath = join14(templateDir, CONFIG_FILENAME);
-  if (!existsSync9(configPath)) {
+  if (!existsSync10(configPath)) {
     throw new TemplateParseError(`Template config not found: ${CONFIG_FILENAME}`, void 0, [
       `Expected file at: ${configPath}`
     ]);
   }
-  const configContent = await readFile5(configPath, "utf-8");
+  const configContent = await readFile6(configPath, "utf-8");
   let rawConfig;
   try {
     rawConfig = (0, import_yaml.parse)(configContent);
@@ -53041,7 +53163,7 @@ async function loadTemplateByName(templatesDir, templateName) {
   return loadTemplate(templateDir);
 }
 async function listTemplates(templatesDir) {
-  if (!existsSync9(templatesDir)) {
+  if (!existsSync10(templatesDir)) {
     return [];
   }
   const entries = await readdir6(templatesDir, { withFileTypes: true });
@@ -53049,7 +53171,7 @@ async function listTemplates(templatesDir) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const configPath = join14(templatesDir, entry.name, CONFIG_FILENAME);
-    if (!existsSync9(configPath)) continue;
+    if (!existsSync10(configPath)) continue;
     try {
       const loaded = await loadTemplate(join14(templatesDir, entry.name));
       templates.push(loaded.config);
@@ -53060,8 +53182,8 @@ async function listTemplates(templatesDir) {
 }
 
 // src/codegen/runner.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { appendFile, mkdir as mkdir7, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync11 } from "node:fs";
+import { appendFile, mkdir as mkdir8, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname3, join as join15 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
@@ -59838,7 +59960,7 @@ async function executeAddAction(action, template, context, options2, result) {
   const sourcePath = join15(template.templateDir, action.template);
   const destRelative = renderPath(action.path, context);
   const destPath = join15(options2.projectRoot, template.config.destination || "", destRelative);
-  if (existsSync10(destPath)) {
+  if (existsSync11(destPath)) {
     if (action.skipIfExists && !options2.force) {
       result.skipped.push(destRelative);
       return;
@@ -59851,7 +59973,7 @@ async function executeAddAction(action, template, context, options2, result) {
   const content = await renderFile(sourcePath, context);
   if (!options2.dryRun) {
     await ensureDir(dirname3(destPath));
-    await writeFile3(destPath, content, "utf-8");
+    await writeFile4(destPath, content, "utf-8");
   }
   result.created.push(destRelative);
 }
@@ -59863,7 +59985,7 @@ async function executeAddManyAction(action, template, context, options2, result)
     const sourcePath = join15(sourceDir, file3);
     const destRelative = renderPath(join15(action.destination, file3), context);
     const destPath = join15(options2.projectRoot, template.config.destination || "", destRelative);
-    if (existsSync10(destPath)) {
+    if (existsSync11(destPath)) {
       if (action.skipIfExists && !options2.force) {
         result.skipped.push(destRelative);
         continue;
@@ -59876,17 +59998,17 @@ async function executeAddManyAction(action, template, context, options2, result)
     const content = await renderFile(sourcePath, context);
     if (!options2.dryRun) {
       await ensureDir(dirname3(destPath));
-      await writeFile3(destPath, content, "utf-8");
+      await writeFile4(destPath, content, "utf-8");
     }
     result.created.push(destRelative);
   }
 }
 async function executeModifyAction(action, context, options2, result) {
   const filePath = join15(options2.projectRoot, renderPath(action.path, context));
-  if (!existsSync10(filePath)) {
+  if (!existsSync11(filePath)) {
     throw new Error(`Cannot modify: file not found: ${action.path}`);
   }
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const replacement = renderString(action.template, context);
   const pattern = new RegExp(action.pattern, "g");
   const newContent = content.replace(pattern, replacement);
@@ -59895,15 +60017,15 @@ async function executeModifyAction(action, context, options2, result) {
     return;
   }
   if (!options2.dryRun) {
-    await writeFile3(filePath, newContent, "utf-8");
+    await writeFile4(filePath, newContent, "utf-8");
   }
   result.modified.push(action.path);
 }
 async function executeAppendAction(action, context, options2, result) {
   const filePath = join15(options2.projectRoot, renderPath(action.path, context));
   const contentToAppend = renderString(action.template, context);
-  if (action.unique && existsSync10(filePath)) {
-    const existingContent = await readFile6(filePath, "utf-8");
+  if (action.unique && existsSync11(filePath)) {
+    const existingContent = await readFile7(filePath, "utf-8");
     if (existingContent.includes(contentToAppend.trim())) {
       result.skipped.push(action.path);
       return;
@@ -59913,21 +60035,21 @@ async function executeAppendAction(action, context, options2, result) {
   const fullContent = separator + contentToAppend;
   if (!options2.dryRun) {
     await ensureDir(dirname3(filePath));
-    if (existsSync10(filePath)) {
+    if (existsSync11(filePath)) {
       await appendFile(filePath, fullContent, "utf-8");
     } else {
-      await writeFile3(filePath, contentToAppend, "utf-8");
+      await writeFile4(filePath, contentToAppend, "utf-8");
     }
   }
-  if (existsSync10(filePath)) {
+  if (existsSync11(filePath)) {
     result.modified.push(action.path);
   } else {
     result.created.push(action.path);
   }
 }
 async function ensureDir(dir) {
-  if (!existsSync10(dir)) {
-    await mkdir7(dir, { recursive: true });
+  if (!existsSync11(dir)) {
+    await mkdir8(dir, { recursive: true });
   }
 }
 
@@ -59935,7 +60057,7 @@ async function ensureDir(dir) {
 var import_gray_matter4 = __toESM(require_gray_matter(), 1);
 
 // src/mcp/handlers/template.ts
-var TEMPLATES_DIR2 = join16(process.cwd(), ".knowns", "templates");
+var TEMPLATES_DIR3 = join16(process.cwd(), ".knowns", "templates");
 var listTemplatesSchema = external_exports3.object({});
 var getTemplateSchema = external_exports3.object({
   name: external_exports3.string()
@@ -60028,30 +60150,45 @@ var templateTools = [
 ];
 async function handleListTemplates(_args) {
   listTemplatesSchema.parse(_args);
-  if (!existsSync11(TEMPLATES_DIR2)) {
-    return successResponse({
-      count: 0,
-      templates: [],
-      message: "No templates directory found. Create templates in .knowns/templates/"
-    });
-  }
+  const projectRoot = process.cwd();
   try {
-    const templates = await listTemplates(TEMPLATES_DIR2);
-    if (templates.length === 0) {
+    const allTemplates = await listAllTemplates(projectRoot);
+    if (allTemplates.length === 0) {
       return successResponse({
         count: 0,
         templates: [],
-        message: "No templates found in .knowns/templates/"
+        message: "No templates found. Create templates in .knowns/templates/"
       });
     }
-    const templateList = templates.map((t) => ({
-      name: t.name,
-      description: t.description,
-      doc: t.doc,
-      // Linked documentation
-      promptCount: t.prompts?.length || 0,
-      fileCount: t.files?.length || 0
-    }));
+    const templateList = [];
+    for (const t of allTemplates) {
+      try {
+        const loaded = await listTemplates(join16(t.path, ".."));
+        const match2 = loaded.find((l) => l.name === t.name);
+        templateList.push({
+          name: t.name,
+          ref: t.ref,
+          description: match2?.description || "No description",
+          doc: match2?.doc,
+          promptCount: match2?.prompts?.length || 0,
+          fileCount: match2?.files?.length || 0,
+          source: t.source,
+          sourceUrl: t.sourceUrl,
+          isImported: t.isImported
+        });
+      } catch {
+        templateList.push({
+          name: t.name,
+          ref: t.ref,
+          description: "No description",
+          promptCount: 0,
+          fileCount: 0,
+          source: t.source,
+          sourceUrl: t.sourceUrl,
+          isImported: t.isImported
+        });
+      }
+    }
     return successResponse({
       count: templateList.length,
       templates: templateList
@@ -60062,11 +60199,11 @@ async function handleListTemplates(_args) {
 }
 async function handleGetTemplate(args) {
   const input = getTemplateSchema.parse(args);
-  if (!existsSync11(TEMPLATES_DIR2)) {
+  if (!existsSync12(TEMPLATES_DIR3)) {
     return errorResponse("No templates directory found");
   }
   try {
-    const template = await loadTemplateByName(input.name, TEMPLATES_DIR2);
+    const template = await loadTemplateByName(input.name, TEMPLATES_DIR3);
     if (!template) {
       return errorResponse(`Template not found: ${input.name}`);
     }
@@ -60102,11 +60239,11 @@ async function handleGetTemplate(args) {
 async function handleRunTemplate(args) {
   const input = runTemplateSchema.parse(args);
   const dryRun = input.dryRun !== false;
-  if (!existsSync11(TEMPLATES_DIR2)) {
+  if (!existsSync12(TEMPLATES_DIR3)) {
     return errorResponse("No templates directory found");
   }
   try {
-    const template = await loadTemplateByName(input.name, TEMPLATES_DIR2);
+    const template = await loadTemplateByName(input.name, TEMPLATES_DIR3);
     if (!template) {
       return errorResponse(`Template not found: ${input.name}`);
     }
@@ -60154,14 +60291,14 @@ async function handleRunTemplate(args) {
 async function handleCreateTemplate(args) {
   const input = createTemplateSchema.parse(args);
   try {
-    if (!existsSync11(TEMPLATES_DIR2)) {
-      await mkdir8(TEMPLATES_DIR2, { recursive: true });
+    if (!existsSync12(TEMPLATES_DIR3)) {
+      await mkdir9(TEMPLATES_DIR3, { recursive: true });
     }
-    const templateDir = join16(TEMPLATES_DIR2, input.name);
-    if (existsSync11(templateDir)) {
+    const templateDir = join16(TEMPLATES_DIR3, input.name);
+    if (existsSync12(templateDir)) {
       return errorResponse(`Template "${input.name}" already exists`);
     }
-    await mkdir8(templateDir, { recursive: true });
+    await mkdir9(templateDir, { recursive: true });
     const docLine = input.doc ? `doc: ${input.doc}
 ` : "";
     const configContent = `# Template: ${input.name}
@@ -60187,7 +60324,7 @@ messages:
   success: |
     \u2713 Created {{name}}!
 `;
-    await writeFile4(join16(templateDir, "_template.yaml"), configContent, "utf-8");
+    await writeFile5(join16(templateDir, "_template.yaml"), configContent, "utf-8");
     const exampleTemplate = `/**
  * {{pascalCase name}}
  * Generated from ${input.name} template
@@ -60197,7 +60334,7 @@ export function {{camelCase name}}() {
   console.log("Hello from {{name}}!");
 }
 `;
-    await writeFile4(join16(templateDir, "example.ts.hbs"), exampleTemplate, "utf-8");
+    await writeFile5(join16(templateDir, "example.ts.hbs"), exampleTemplate, "utf-8");
     return successResponse({
       message: `Created template: ${input.name}`,
       template: {
@@ -60220,8 +60357,8 @@ export function {{camelCase name}}() {
 
 // src/mcp/handlers/search.ts
 var import_gray_matter5 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile7, readdir as readdir8 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { readFile as readFile8, readdir as readdir8 } from "node:fs/promises";
 import { join as join17 } from "node:path";
 var searchSchema = external_exports3.object({
   query: external_exports3.string(),
@@ -60309,7 +60446,7 @@ function calculateDocScore(title, description, content, tags, query) {
 }
 async function getAllMdFiles2(dir, basePath = "") {
   const files = [];
-  if (!existsSync12(dir)) {
+  if (!existsSync13(dir)) {
     return files;
   }
   const entries = await readdir8(dir, { withFileTypes: true });
@@ -60357,14 +60494,14 @@ async function searchTasks(fileStore2, query, filters) {
   })).sort((a, b) => b.score - a.score);
 }
 async function searchDocs(docsDir, query, tagFilter) {
-  if (!existsSync12(docsDir)) {
+  if (!existsSync13(docsDir)) {
     return [];
   }
   const mdFiles = await getAllMdFiles2(docsDir);
   const q = query.toLowerCase();
   const results = [];
   for (const file3 of mdFiles) {
-    const fileContent = await readFile7(join17(docsDir, file3), "utf-8");
+    const fileContent = await readFile8(join17(docsDir, file3), "utf-8");
     const { data, content } = (0, import_gray_matter5.default)(fileContent);
     const metadata = data;
     if (tagFilter && !metadata.tags?.includes(tagFilter)) {
@@ -60528,7 +60665,7 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
     description: `Task #${task.id}: ${task.title}`
   }));
   const docResources = [];
-  if (existsSync13(docsDir)) {
+  if (existsSync14(docsDir)) {
     const { readdir: readdir9 } = await import("node:fs/promises");
     async function getAllMdFiles3(dir, basePath = "") {
       const files = [];
@@ -60548,7 +60685,7 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
     const mdFiles = await getAllMdFiles3(docsDir);
     for (const file3 of mdFiles) {
       const filepath = join18(docsDir, file3);
-      const content = await readFile8(filepath, "utf-8");
+      const content = await readFile9(filepath, "utf-8");
       const { data } = (0, import_gray_matter6.default)(content);
       docResources.push({
         uri: `knowns://doc/${file3.replace(/\.md$/, "")}`,
@@ -60586,10 +60723,10 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const docPath = docMatch[1];
     const docsDir = join18(process.cwd(), ".knowns", "docs");
     const filepath = join18(docsDir, `${docPath}.md`);
-    if (!existsSync13(filepath)) {
+    if (!existsSync14(filepath)) {
       throw new Error(`Documentation ${docPath} not found`);
     }
-    const content = await readFile8(filepath, "utf-8");
+    const content = await readFile9(filepath, "utf-8");
     const { data, content: docContent } = (0, import_gray_matter6.default)(content);
     return {
       contents: [