akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/proposal/validators/proposal-quality-validators.js

@@ -65,16 +65,10 @@ import { proposalContent } from "../../../core/file-change.js";
 /**
  * The canonical asset NAME an inputRef names, lower-cased — the tail the
  * "just restates the ref" heuristics compare against. WI-8.5c: the ref is the
- * conceptId (`<subdir>/<name>`), so the name is parsed off the conceptId; a
- * legacy `type:name` falls back to the post-colon segment.
+ * conceptId (`<subdir>/<name>`), so the name is parsed off the conceptId.
  */
 function refNameTail(inputRef) {
-    try {
-        return parseRefInput(inputRef).name.toLowerCase();
-    }
-    catch {
-        return (inputRef.split(":").pop() ?? "").toLowerCase();
-    }
+    return parseRefInput(inputRef).name.toLowerCase();
 }
 import { detectTruncatedDescription, TRUNCATION_TRAILING_WORDS } from "../../../core/text-truncation.js";
 // ── Description / when_to_use shape ─────────────────────────────────────────

package/dist/commands/proposal/validators/proposal-validators.js

@@ -5,6 +5,8 @@ import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { proposalContent } from "../../../core/file-change.js";
 import { lintLessonContent } from "../../../core/lesson-lint.js";
+import { parseTaskDocument } from "../../../tasks/parser.js";
+import { parseWorkflow } from "../../../workflows/parser.js";
 import { defaultProposalQualityValidators } from "./proposal-quality-validators.js";
 const genericProposalValidator = {
     name: "generic-proposal-validator",
@@ -39,21 +41,67 @@ const genericProposalValidator = {
         return findings;
     },
 };
-const lessonProposalValidator = {
-    name: "lesson-proposal-validator",
-    appliesTo(_proposal, ctx) {
-        return ctx.parsedRef?.type === "lesson";
-    },
-    validate(proposal) {
+const canonicalProposalValidators = {
+    lesson(proposal) {
         return lintLessonContent(proposalContent(proposal), `proposal:${proposal.id}`).findings.map((finding) => ({
             kind: finding.kind,
             message: finding.message,
         }));
     },
+    task(proposal, ctx) {
+        const name = ctx.parsedRef?.name;
+        if (!name)
+            return [];
+        parseTaskDocument({
+            yaml: proposalContent(proposal),
+            filePath: proposal.changes[0]?.path || proposal.ref,
+            id: name,
+        });
+        return [];
+    },
+    workflow(proposal) {
+        const content = proposalContent(proposal);
+        if (!content.trim())
+            return [];
+        const changePath = proposal.changes[0]?.path ?? "";
+        const result = parseWorkflow(content, { path: changePath || proposal.ref });
+        if (result.ok)
+            return [];
+        return result.errors.map((error) => ({
+            kind: "invalid-workflow-structure",
+            message: `Workflow proposal ${proposal.id} (${proposal.ref}) is invalid at line ${error.line}: ${error.message}`,
+        }));
+    },
+};
+export function hasCanonicalProposalValidator(type) {
+    return Object.hasOwn(canonicalProposalValidators, type);
+}
+const canonicalProposalValidator = {
+    name: "canonical-asset-proposal-validator",
+    appliesTo(_proposal, ctx) {
+        return ctx.parsedRef !== undefined && hasCanonicalProposalValidator(ctx.parsedRef.type);
+    },
+    validate(proposal, ctx) {
+        const type = ctx.parsedRef?.type;
+        const validator = type ? canonicalProposalValidators[type] : undefined;
+        if (!validator)
+            return [];
+        try {
+            return validator(proposal, ctx);
+        }
+        catch (error) {
+            return [
+                {
+                    kind: `invalid-${type}-structure`,
+                    message: `${type} proposal ${proposal.id} (${proposal.ref}) is invalid: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ];
+        }
+    },
 };
 export const defaultProposalValidators = [
     genericProposalValidator,
-    lessonProposalValidator,
+    canonicalProposalValidator,
     ...defaultProposalQualityValidators,
 ];
 export function runProposalValidators(proposal, validators = defaultProposalValidators, initialContext = {}) {

package/dist/commands/proposal/validators/proposals.js

@@ -5,19 +5,16 @@
  * Proposal validation and content repair.
  *
  * The proposal repository and domain service moved to `../repository.ts` (#578
- * storage consolidation); the legacy filesystem import now lives in the migrator
- * (`../../../migrate/legacy/proposal-fs-import.ts`). This module keeps only the
- * two proposal *validators* — {@link validateProposal} and
+ * storage consolidation). This module keeps only the two proposal *validators* — {@link validateProposal} and
  * {@link repairProposalContent}.
  */
 import { repairTruncatedDescription } from "../../../core/text-truncation.js";
 import { runProposalValidators } from "./proposal-validators.js";
 /**
  * Validate a proposal payload before promotion. Generic by default — any
- * proposal must parse cleanly and carry a non-empty body. Lessons get the
- * extra per-type lint from {@link lintLessonContent} so the contract documented
- * in v1 spec §13 is enforced at promotion time. Other asset types can hook
- * here in the future without changing call sites.
+ * proposal must parse cleanly and carry a non-empty body. Asset types in the
+ * fail-closed canonical registry run their existing parser or validator; types
+ * without one remain on generic validation.
  */
 export function validateProposal(proposal) {
     return runProposalValidators(proposal);

package/dist/commands/read/curate.js

@@ -24,7 +24,7 @@ import { enqueueGraphExtraction, hasGraphData } from "../../indexer/db/graph-db.
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
-import { truncateDescription } from "../../output/shapes.js";
+import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { findEntryIdByRef, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
 import { computeBodyHash } from "../../storage/repositories/index-llm-cache-repository.js";
@@ -74,12 +74,12 @@ function logCurateEvent(query, result, eventSource = "user", attributionProjecti
             // state.db (Chunk-8 WI-8.3).
             const perItem = result.items
                 .filter((item) => "ref" in item && typeof item.ref === "string")
-                .map((item) => {
+                .flatMap((item) => {
                 const entryId = findEntryIdByRef(db, item.ref);
-                const itemRef = entryId !== undefined ? getItemRefById(db, entryId) : null;
-                // Post-flip the resolved row carries `item_ref`; fall back to the
-                // item's own (new-grammar) ref for an unresolved straggler.
-                return { entryRef: itemRef ?? item.ref, entryId, item };
+                if (entryId === undefined)
+                    return [];
+                const itemRef = getItemRefById(db, entryId);
+                return itemRef ? [{ entryRef: itemRef, entryId, item }] : [];
             });
             withStateDbTelemetry((stateDb) => {
                 insertUsageEvent(stateDb, {
@@ -114,7 +114,7 @@ export async function akmCurate(options) {
         throw new UsageError('A curation query is required. Usage: akm curate "<task or prompt>" [--type <type>] [--limit <n>]', "MISSING_REQUIRED_ARGUMENT");
     }
     const limit = options.limit && options.limit > 0 ? options.limit : DEFAULT_CURATE_LIMIT;
-    const source = options.source ?? parseSearchSource("stash");
+    const source = options.source ?? parseSearchSource("local");
     const searchResponse = options.searchResponse ??
         (await searchForCuration({
             query: options.query,
@@ -123,24 +123,30 @@ export async function akmCurate(options) {
             source,
         }));
     const result = await curateSearchResults(options.query, searchResponse, limit, options.type, options.eventSource);
-    logCurateEvent(options.query, result, options.eventSource, options.attributionProjection);
+    if (!options.skipLogging) {
+        logCurateEvent(options.query, result, options.eventSource, options.attributionProjection);
+    }
     return result;
 }
 export async function curateSearchResults(query, result, limit, selectedType, eventSource) {
-    const stashHits = result.hits.filter((hit) => hit.type !== "registry");
+    const allStashHits = result.hits.filter((hit) => hit.type !== "registry");
     const registryHits = result.registryHits ?? [];
-    let selectedStashHits;
-    let supportRefsByRef = new Map();
-    if (selectedType && selectedType !== "any") {
-        selectedStashHits = stashHits.slice(0, limit);
-    }
-    else {
-        const selected = selectCuratedStashHits(query, stashHits, limit);
-        const preferred = preferBroadRootRepresentative(query, selected.selected, stashHits, selected.supportRefsByRef);
-        selectedStashHits = preferred.selected;
-        supportRefsByRef = preferred.supportRefsByRef;
-    }
-    const selectedRegistryHits = selectedStashHits.length >= limit ? [] : registryHits.slice(0, Math.min(2, limit - selectedStashHits.length));
+    // F3/R-018: `--type` must NARROW the candidate pool, not bypass curation.
+    // Previously a set `selectedType` skipped `selectCuratedStashHits` (ranking,
+    // intent nudges, score floor) entirely, taking the raw top-N of whatever
+    // order the hits arrived in. Filtering the pool down to the requested type up front and
+    // then running the SAME pipeline over it gives `--type` its intended
+    // "narrow, don't disable" semantics — and matters even when the caller's
+    // search already applied a type filter at the DB layer, because
+    // `curateSearchResults` is also driven directly (tests, `searchResponse`
+    // fixtures) with a `SearchResponse` that was never type-filtered.
+    const stashHits = selectedType && selectedType !== "any" ? allStashHits.filter((hit) => hit.type === selectedType) : allStashHits;
+    const selected = selectCuratedStashHits(query, stashHits, limit);
+    const selectedStashHits = selected.selected;
+    const supportRefsByRef = selected.supportRefsByRef;
+    // F4/R-019: respect `--limit` for registry fill instead of hard-capping it
+    // at a bare literal 2 — the remaining slots after stash hits ARE the cap.
+    const selectedRegistryHits = selectedStashHits.length >= limit ? [] : registryHits.slice(0, limit - selectedStashHits.length);
     const selectedRefs = new Set(selectedStashHits.map((hit) => hit.ref));
     const items = [
         ...(await Promise.all(selectedStashHits
@@ -173,10 +179,15 @@ async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, even
     const preview = buildCuratedPreview(shown, hit);
     const mergedSupportRefs = mergeCurateSupportRefs(supportRefs, shown?.related?.hits, selectedRefs, hit.ref);
     const item = {
-        source: "stash",
+        source: "local",
         type: shown?.type ?? hit.type,
         name: shown?.name ?? hit.name,
         ref: hit.ref,
+        path: shown?.path ?? hit.path,
+        editable: shown?.editable ?? hit.editable ?? false,
+        ...((shown?.editable ?? hit.editable ?? false) === false
+            ? { editHint: shown?.editHint ?? hit.editHint ?? `This asset is read-only. Inspect it with: akm show ${hit.ref}` }
+            : {}),
         ...(description ? { description } : {}),
         ...(preview ? { preview } : {}),
         ...(shown?.keys?.length ? { keys: shown.keys } : {}),
@@ -235,7 +246,7 @@ function buildCuratedRegistryItem(query, hit) {
         name: hit.name,
         id: hit.id,
         ...(hit.description ? { description: hit.description } : {}),
-        followUp: hit.action ?? `akm add ${hit.id}`,
+        followUp: hit.action ?? `akm bundle add ${hit.id}`,
         reason: `Useful external source to explore for ${query}.`,
         ...(hit.score !== undefined ? { score: hit.score } : {}),
     };
@@ -580,36 +591,6 @@ function collapseCurateFamilies(query, hits) {
         supportRefsByRef,
     };
 }
-function preferBroadRootRepresentative(query, selected, allHits, supportRefsByRef) {
-    const first = selected[0];
-    if (!first)
-        return { selected, supportRefsByRef };
-    const match = /^knowledge:skills\/(.+?)\/references\/(.+)$/.exec(first.ref);
-    if (!match)
-        return { selected, supportRefsByRef };
-    const lower = query.toLowerCase();
-    const topicTokens = match[2].split(/[^a-z0-9]+/i).filter(Boolean);
-    const wantsReference = CURATE_REFERENCE_QUERY_RE.test(lower) ||
-        topicTokens.some((token) => token.length >= 3 && lower.includes(token.toLowerCase()));
-    if (wantsReference)
-        return { selected, supportRefsByRef };
-    const rootRef = `skill:${match[1]}`;
-    const rootHit = allHits.find((hit) => hit.ref === rootRef);
-    if (!rootHit)
-        return { selected, supportRefsByRef };
-    const next = [rootHit, ...selected.filter((hit) => hit.ref !== first.ref && hit.ref !== rootRef)];
-    const merged = new Map(supportRefsByRef);
-    const priorSupport = merged.get(first.ref) ?? [];
-    for (const entry of priorSupport)
-        appendCurateSupportRef(merged, rootRef, entry);
-    appendCurateSupportRef(merged, rootRef, {
-        ref: first.ref,
-        type: first.type,
-        reason: "Related family asset to inspect next.",
-    });
-    merged.delete(first.ref);
-    return { selected: next, supportRefsByRef: merged };
-}
 function mergeCurateSupportRefs(seeded, relatedHits, selectedRefs, ownerRef) {
     const merged = [];
     for (const entry of seeded) {