akm-cli 0.6.0 → 0.6.1

package/dist/cli.js

@@ -445,7 +445,8 @@ const showCommand = defineCommand({
                 }
             }
             const cliDetail = getOutputMode().detail;
-            const showDetail = cliDetail === "summary" ? "summary" : undefined;
+            const explicitDetail = parseFlagValue(process.argv, "--detail");
+            const showDetail = explicitDetail === "brief" ? "brief" : cliDetail === "summary" ? "summary" : undefined;
             const result = await akmShowUnified({ ref: args.ref, view, detail: showDetail });
             output("show", result);
         });
@@ -1535,6 +1536,53 @@ function listVaultsRecursive(listKeysFn) {
     walk(vaultsDir);
     return result;
 }
+function wasRefMisparsedAsFlagValue(ref, flag, flagValue) {
+    const argv = process.argv.slice(2);
+    const vaultIndex = argv.indexOf("vault");
+    const listIndex = vaultIndex >= 0 ? argv.indexOf("list", vaultIndex + 1) : -1;
+    const tokens = listIndex >= 0 ? argv.slice(listIndex + 1) : argv;
+    let flagIndex = -1;
+    let flagConsumesNextToken = false;
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === flag) {
+            flagIndex = i;
+            flagConsumesNextToken = true;
+            break;
+        }
+        if (token === `${flag}=${flagValue}`) {
+            flagIndex = i;
+            break;
+        }
+    }
+    if (flagIndex === -1)
+        return false;
+    // If the same token appeared before the flag, the user explicitly passed it
+    // as the positional ref and it was not consumed by the output flag.
+    if (tokens.slice(0, flagIndex).includes(ref))
+        return false;
+    // Skip past either `--flag value` (2 tokens) or `--flag=value` (1 token)
+    // before checking whether the ref appears elsewhere as a real positional.
+    const TOKENS_AFTER_SPACE_FLAG = 2;
+    const TOKENS_AFTER_EQUALS_FLAG = 1;
+    const firstTokenAfterFlag = flagIndex + (flagConsumesNextToken ? TOKENS_AFTER_SPACE_FLAG : TOKENS_AFTER_EQUALS_FLAG);
+    if (tokens.slice(firstTokenAfterFlag).includes(ref))
+        return false;
+    return true;
+}
+function resolveVaultListRef(ref) {
+    if (ref === undefined)
+        return undefined;
+    const parsedFormat = parseFlagValue(process.argv, "--format");
+    if (parsedFormat !== undefined && ref === parsedFormat && wasRefMisparsedAsFlagValue(ref, "--format", parsedFormat)) {
+        return undefined;
+    }
+    const parsedDetail = parseFlagValue(process.argv, "--detail");
+    if (parsedDetail !== undefined && ref === parsedDetail && wasRefMisparsedAsFlagValue(ref, "--detail", parsedDetail)) {
+        return undefined;
+    }
+    return ref;
+}
 const vaultListCommand = defineCommand({
     meta: { name: "list", description: "List vaults, or list keys (no values) inside one vault" },
     args: {
@@ -1543,8 +1591,9 @@ const vaultListCommand = defineCommand({
     run({ args }) {
         return runWithJsonErrors(async () => {
             const { listKeys, listEntries } = await import("./commands/vault.js");
-            if (args.ref) {
-                const { name, absPath } = resolveVaultPath(args.ref);
+            const effectiveRef = resolveVaultListRef(args.ref);
+            if (effectiveRef) {
+                const { name, absPath } = resolveVaultPath(effectiveRef);
                 if (!fs.existsSync(absPath)) {
                     throw new NotFoundError(`Vault not found: vault:${name}`);
                 }

package/dist/commands/installed-stashes.js

@@ -6,7 +6,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { resolveStashDir } from "../core/common";
+import { isWithin, resolveStashDir } from "../core/common";
 import { loadConfig } from "../core/config";
 import { NotFoundError, UsageError } from "../core/errors";
 import { akmIndex } from "../indexer/indexer";
@@ -14,6 +14,7 @@ import { removeLockEntry, upsertLockEntry } from "../integrations/lockfile";
 import { parseRegistryRef } from "../registry/resolve";
 import { syncFromRef } from "../sources/providers/sync-from-ref";
 import { ensureWebsiteMirror } from "../sources/providers/website";
+import { listWikis, resolveWikisRoot } from "../wiki/wiki";
 import { auditInstallCandidate, deriveRegistryLabels, enforceRegistryInstallPolicy, formatInstallAuditFailure, } from "./install-audit";
 import { removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./source-add";
 import { removeStash } from "./source-manage";
@@ -57,6 +58,31 @@ export async function akmListSources(input) {
             status: { exists: directoryExists(entry.stashRoot) },
         });
     }
+    if (!kindFilter || kindFilter.includes("filesystem")) {
+        const wikisRoot = resolveWikisRoot(stashDir);
+        const seenPaths = new Set(sources
+            .map((source) => source.path)
+            .filter((sourcePath) => typeof sourcePath === "string")
+            .map((sourcePath) => path.resolve(sourcePath)));
+        for (const wiki of listWikis(stashDir)) {
+            // `listWikis()` also includes externally-registered wikis. `akm list`
+            // should synthesize source entries here only for stash-owned wiki dirs.
+            if (!isWithin(wiki.path, wikisRoot))
+                continue;
+            const resolvedPath = path.resolve(wiki.path);
+            if (seenPaths.has(resolvedPath))
+                continue;
+            seenPaths.add(resolvedPath);
+            sources.push({
+                name: wiki.name,
+                kind: "filesystem",
+                wiki: wiki.name,
+                path: wiki.path,
+                writable: true,
+                status: { exists: directoryExists(wiki.path) },
+            });
+        }
+    }
     return {
         schemaVersion: 1,
         stashDir,

package/dist/commands/show.js

@@ -98,8 +98,8 @@ function resolveRegisteredWikiAssetPath(wikiRoot, wikiName, assetName) {
  * type-dir resolution if the index has no row. Spec §6.2; no remote provider
  * fallback.
  *
- * When `detail` is `"summary"`, the response omits content/template/prompt and
- * returns only compact metadata (name, type, description, tags, parameters).
+ * When `detail` is `"brief"` or `"summary"`, the response omits
+ * content/template/prompt and returns compact metadata.
  */
 export async function akmShowUnified(input) {
     const ref = input.ref.trim();
@@ -251,6 +251,9 @@ export async function showLocal(input) {
         editable,
         ...(!editable ? { editHint: buildEditHint(assetPath, parsed.type, parsed.name, source?.registryId) } : {}),
     };
+    if (input.detail === "brief") {
+        return buildBriefResponse(fullResponse, assetPath);
+    }
     if (input.detail === "summary") {
         return buildSummaryResponse(fullResponse, assetPath);
     }
@@ -270,6 +273,24 @@ export async function showByRef(ref) {
     const body = await fs.promises.readFile(entry.filePath, "utf8");
     return { filePath: entry.filePath, body };
 }
+/**
+ * Build a reduced brief response from a full ShowResponse.
+ *
+ * Keeps routing/identification fields while omitting content/template/prompt.
+ */
+function buildBriefResponse(full, assetPath) {
+    const summary = buildSummaryResponse(full, assetPath);
+    return {
+        type: summary.type,
+        name: summary.name,
+        path: summary.path,
+        ...(summary.description ? { description: summary.description } : {}),
+        ...(summary.action ? { action: summary.action } : {}),
+        ...(summary.run ? { run: summary.run } : {}),
+        ...(summary.origin !== undefined ? { origin: summary.origin } : {}),
+        ...(full.editable !== undefined ? { editable: full.editable } : {}),
+    };
+}
 /**
  * Build a compact summary response from a full ShowResponse.
  *

package/dist/indexer/db-search.js

@@ -17,7 +17,7 @@ import { defaultRendererRegistry } from "../core/asset-registry";
 import { deriveCanonicalAssetNameFromStashRoot } from "../core/asset-spec";
 import { getDbPath } from "../core/paths";
 import { warn } from "../core/warn";
-import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, getUtilityScoresByIds, openDatabase, searchFts, searchVec, } from "./db";
+import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, getUtilityScoresByIds, openDatabase, sanitizeFtsQuery, searchFts, searchVec, } from "./db";
 import { getRenderer } from "./file-context";
 import { generateMetadataFlat, loadStashFile, shouldIndexStashFile } from "./metadata";
 import { buildSearchText } from "./search-fields";
@@ -115,8 +115,11 @@ export async function searchLocal(input) {
 }
 // ── Database search ─────────────────────────────────────────────────────────
 async function searchDatabase(db, query, searchType, limit, stashDir, allSourceDirs, config, sources, rendererRegistry = defaultRendererRegistry) {
-    // Empty query: return all entries
-    if (!query) {
+    const hasSearchableTokens = query.length > 0 && sanitizeFtsQuery(query).length > 0;
+    // Empty queries — including ones that sanitize down to no searchable FTS
+    // tokens such as "." — should enumerate matching entries instead of
+    // returning an empty result set from FTS.
+    if (!hasSearchableTokens) {
         const typeFilter = searchType === "any" ? undefined : searchType;
         const allEntries = getAllEntries(db, typeFilter);
         // Deduplicate by file path — multiple entries can share the same file

package/dist/indexer/metadata.js

@@ -255,10 +255,9 @@ const WIKI_INFRA_FILES = new Set(["schema.md", "index.md", "log.md"]);
  * Apply wiki-specific index exclusions while leaving all other stash files
  * untouched.
  *
- * - In a normal stash, excludes `wikis/<name>/raw/**` and wiki-root
- *   `schema.md`, `index.md`, `log.md`.
- * - In a wiki-root stash source (`wikiName`), excludes `raw/**` and those same
- *   root-level infrastructure files.
+ * - In a normal stash, excludes wiki-root `schema.md`, `index.md`, `log.md`.
+ * - In a wiki-root stash source (`wikiName`), excludes those same root-level
+ *   infrastructure files.
  */
 export function shouldIndexStashFile(stashRoot, file, options) {
     const relPath = path.relative(stashRoot, file);
@@ -268,8 +267,6 @@ export function shouldIndexStashFile(stashRoot, file, options) {
     if (segments.length === 0)
         return true;
     if (options?.treatStashRootAsWikiRoot) {
-        if (segments[0] === "raw")
-            return false;
         return !(segments.length === 1 && WIKI_INFRA_FILES.has(segments[0]));
     }
     const wikisIdx = segments.indexOf("wikis");
@@ -278,8 +275,6 @@ export function shouldIndexStashFile(stashRoot, file, options) {
     const wikiRelativeSegments = segments.slice(wikisIdx + 2);
     if (wikiRelativeSegments.length === 0)
         return true;
-    if (wikiRelativeSegments[0] === "raw")
-        return false;
     return !(wikiRelativeSegments.length === 1 && WIKI_INFRA_FILES.has(wikiRelativeSegments[0]));
 }
 /**

package/dist/wiki/wiki.js

@@ -99,8 +99,9 @@ export function ensureWikiNameAvailable(stashDir, name) {
  * Walk a wiki directory and bucket files into pages vs raws.
  *
  * "Pages" are any `.md` files under the wiki root EXCEPT `schema.md`,
- * `index.md`, `log.md`, or anything under `raw/`. This matches the set the
- * agent edits, and the set `akm wiki pages` exposes.
+ * `index.md`, or `log.md`. Raw sources are bucketed separately so callers can
+ * distinguish authored pages from ingested source material while still
+ * surfacing both.
  *
  * Returns two mtime signals:
  *   - `lastModifiedMs` — newest across all .md files. Used for the `show` /
@@ -495,15 +496,16 @@ function readPageFrontmatter(absPath) {
     return out;
 }
 /**
- * List the pages in a wiki, excluding `schema.md`, `index.md`, `log.md`, and
- * anything under `raw/`. Each entry carries its ref (`wiki:<name>/<page>`),
- * path, and frontmatter-derived fields for orientation.
+ * List the addressable markdown entries in a wiki, excluding only the
+ * infrastructure files `schema.md`, `index.md`, and `log.md`. This includes
+ * both authored pages and `raw/` sources so `wiki pages` can inventory content
+ * written via `akm wiki stash`.
  */
 export function listPages(stashDir, name) {
     const wikiDir = resolveWikiSource(stashDir, name).path;
-    const { pages } = scanWikiFiles(wikiDir);
+    const { pages, raws } = scanWikiFiles(wikiDir);
     const result = [];
-    for (const abs of pages) {
+    for (const abs of [...pages, ...raws]) {
         const pageName = pageNameFromPath(wikiDir, abs);
         const ref = `wiki:${name}/${pageName}`;
         const fm = readPageFrontmatter(abs);
@@ -540,7 +542,6 @@ export async function searchInWiki(input) {
         }
         throw err;
     }
-    const rawDir = path.join(wikiDir, RAW_SUBDIR);
     const filtered = [];
     for (const hit of response.hits) {
         // hits can be SourceSearchHit or RegistrySearchResultHit (union); filter
@@ -556,9 +557,6 @@ export async function searchInWiki(input) {
         const basename = path.basename(stashHit.path);
         if (WIKI_SPECIAL_FILES.has(basename) && path.dirname(stashHit.path) === wikiDir)
             continue;
-        // Exclude anything under raw/
-        if (isWithin(stashHit.path, rawDir))
-            continue;
         filtered.push(stashHit);
     }
     return { ...response, hits: filtered, registryHits: undefined };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "description": "akm (Agent Kit Manager) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [