@fenglimg/fabric-shared 1.8.0-rc.3 → 2.0.0-rc.1

package/dist/index.js

@@ -1,4 +1,3 @@
-import "./chunk-LXNCAKJZ.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -7,9 +6,16 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "./chunk-FEEWLYO3.js";
+} from "./chunk-KHIM6MWS.js";
 import {
+  KNOWLEDGE_TYPE_CODES,
+  KnowledgeEntryFrontmatterSchema,
+  KnowledgeTypeSchema,
+  LayerSchema,
+  MaturitySchema,
+  StableIdSchema,
   annotateIntentRequestSchema,
+  formatKnowledgeId,
   getRulesAnnotations,
   getRulesInputSchema,
   getRulesOutputSchema,
@@ -18,6 +24,7 @@ import {
   humanLockFileParamsSchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  parseKnowledgeId,
   planContextAnnotations,
   planContextInputSchema,
   planContextOutputSchema,
@@ -25,7 +32,8 @@ import {
   ruleSectionsInputSchema,
   ruleSectionsOutputSchema,
   structuredWarningSchema
-} from "./chunk-KV27CZH3.js";
+} from "./chunk-HACPXMLL.js";
+import "./chunk-LXNCAKJZ.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
@@ -42,7 +50,16 @@ var ruleDescriptionSchema = z.object({
   tech_stack: z.array(z.string()),
   impact: z.array(z.string()),
   must_read_if: z.string(),
-  entities: z.array(z.string()).optional()
+  entities: z.array(z.string()).optional(),
+  // v2.0 knowledge entry fields (TASK-002 schemas). All optional for backward compat.
+  id: z.string().optional(),
+  knowledge_type: z.enum(["model", "decision", "guideline", "pitfall", "process"]).optional(),
+  maturity: z.enum(["draft", "verified", "proven"]).optional(),
+  knowledge_layer: z.enum(["personal", "team"]).optional(),
+  layer_reason: z.string().optional(),
+  created_at: z.string().optional(),
+  // v2/rc.2: flat flow-style YAML array; populated by init-scan from forensic tech stack and editable by user. Used by rc.3 review skill for tag-filter search.
+  tags: z.array(z.string()).default([]).optional()
 }).strict();
 var ruleDescriptionIndexItemSchema = z.object({
   stable_id: z.string(),
@@ -76,13 +93,33 @@ var agentsMetaNodeSchema = z.preprocess((value) => {
   }
   return withDerivedAgentsMetaNodeDefaults(value);
 }, agentsMetaNodeBaseSchema);
+var knowledgeTypeCountersSchema = z.object({
+  MOD: z.number().int().nonnegative().default(0),
+  DEC: z.number().int().nonnegative().default(0),
+  GLD: z.number().int().nonnegative().default(0),
+  PIT: z.number().int().nonnegative().default(0),
+  PRO: z.number().int().nonnegative().default(0)
+}).default({ MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 });
+var AgentsMetaCountersSchema = z.object({
+  KP: knowledgeTypeCountersSchema,
+  KT: knowledgeTypeCountersSchema
+}).default({
+  KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
+  KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
+});
 var agentsMetaSchema = z.object({
   revision: z.string(),
-  nodes: z.record(agentsMetaNodeSchema)
+  nodes: z.record(agentsMetaNodeSchema),
+  counters: AgentsMetaCountersSchema.optional()
 });
+var KNOWLEDGE_STABLE_ID_PATTERN = /^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u;
+function isKnowledgeStableId(stableId) {
+  return stableId !== void 0 && KNOWLEDGE_STABLE_ID_PATTERN.test(stableId);
+}
 function withDerivedAgentsMetaNodeDefaults(node) {
+  const isKnowledgeEntry = isKnowledgeStableId(node.stable_id);
   const stableId = node.stable_id ?? deriveAgentsMetaStableId(node.file);
-  const identitySource = deriveAgentsMetaIdentitySource(node);
+  const identitySource = isKnowledgeEntry ? "declared" : deriveAgentsMetaIdentitySource(node);
   return {
     ...node,
     layer: node.layer ?? node.level ?? deriveAgentsMetaLayer(node.file),
@@ -92,6 +129,27 @@ function withDerivedAgentsMetaNodeDefaults(node) {
     identity_source: identitySource
   };
 }
+function allocateKnowledgeId(layer, type, current) {
+  const layerKey = layer === "personal" ? "KP" : "KT";
+  const typeCode = KNOWLEDGE_TYPE_CODES[type];
+  const previousCount = current[layerKey][typeCode] ?? 0;
+  const nextCount = previousCount + 1;
+  const id = formatKnowledgeId(layer, type, nextCount);
+  const nextCounters = {
+    ...current,
+    [layerKey]: {
+      ...current[layerKey],
+      [typeCode]: nextCount
+    }
+  };
+  return { id, nextCounters };
+}
+function defaultAgentsMetaCounters() {
+  return {
+    KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
+    KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
+  };
+}
 function deriveAgentsMetaStableId(file) {
   const normalized = normalizePath(file);
   if (normalized === "AGENTS.md" || normalized === ".fabric/bootstrap/README.md") {
@@ -103,6 +161,9 @@ function deriveAgentsMetaIdentitySource(node) {
   if (node.identity_source !== void 0) {
     return node.identity_source;
   }
+  if (isKnowledgeStableId(node.stable_id)) {
+    return "declared";
+  }
   const derivedStableId = deriveAgentsMetaStableId(node.file);
   return node.stable_id !== void 0 && node.stable_id !== derivedStableId ? "declared" : "derived";
 }
@@ -226,7 +287,7 @@ var clientPathsSchema = z5.object({
   claudeCodeDesktop: z5.string().optional(),
   cursor: z5.string().optional(),
   codexCLI: z5.string().optional()
-}).passthrough();
+}).strict();
 var mcpPayloadLimitsSchema = z5.object({
   warnBytes: z5.number().int().positive().optional(),
   hardBytes: z5.number().int().positive().optional()
@@ -408,9 +469,9 @@ var eventLedgerEnvelopeSchema = {
   session_id: z9.string().optional()
 };
 var stringRecordSchema = z9.record(z9.string());
-var ruleContextPlannedEventSchema = z9.object({
+var knowledgeContextPlannedEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("rule_context_planned"),
+  event_type: z9.literal("knowledge_context_planned"),
   target_paths: z9.array(z9.string()),
   required_stable_ids: z9.array(z9.string()),
   ai_selectable_stable_ids: z9.array(z9.string()),
@@ -421,9 +482,9 @@ var ruleContextPlannedEventSchema = z9.object({
   known_tech: z9.array(z9.string()).optional(),
   diagnostics: z9.array(z9.unknown()).optional()
 });
-var ruleSelectionEventSchema = z9.object({
+var knowledgeSelectionEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("rule_selection"),
+  event_type: z9.literal("knowledge_selection"),
   selection_token: z9.string(),
   target_paths: z9.array(z9.string()),
   required_stable_ids: z9.array(z9.string()),
@@ -434,9 +495,9 @@ var ruleSelectionEventSchema = z9.object({
   rejected_stable_ids: z9.array(z9.string()),
   ignored_stable_ids: z9.array(z9.string())
 });
-var ruleSectionsFetchedEventSchema = z9.object({
+var knowledgeSectionsFetchedEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("rule_sections_fetched"),
+  event_type: z9.literal("knowledge_sections_fetched"),
   selection_token: z9.string(),
   target_paths: z9.array(z9.string()).optional(),
   requested_sections: z9.array(z9.string()),
@@ -460,9 +521,9 @@ var editIntentCheckedEventSchema = z9.object({
   matched_rule_context_ts: z9.number().int().nonnegative().nullable(),
   window_ms: z9.number().int().nonnegative()
 });
-var ruleDriftDetectedEventSchema = z9.object({
+var knowledgeDriftDetectedEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("rule_drift_detected"),
+  event_type: z9.literal("knowledge_drift_detected"),
   revision: z9.string().optional(),
   drifted_stable_ids: z9.array(z9.string()),
   missing_files: z9.array(z9.string()),
@@ -476,23 +537,6 @@ var ruleDriftDetectedEventSchema = z9.object({
     })
   ).optional()
 });
-var ruleBaselineAcceptedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("rule_baseline_accepted"),
-  revision: z9.string(),
-  previous_revision: z9.string().optional(),
-  accepted_stable_ids: z9.array(z9.string()),
-  source: z9.enum(["doctor_fix", "sync_meta"]).optional()
-});
-var baselineSyncedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("baseline_synced"),
-  revision: z9.string(),
-  previous_revision: z9.string().optional(),
-  synced_files: z9.array(z9.string()),
-  accepted_stable_ids: z9.array(z9.string()),
-  source: z9.enum(["doctor_fix", "sync_meta"])
-});
 var mcpEventLedgerEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
   event_type: z9.literal("mcp_event"),
@@ -553,19 +597,19 @@ var codexSkillPathMigratedEventSchema = z9.object({
   from: z9.string(),
   to: z9.string()
 });
-var legacyClientPathPresentEventSchema = z9.object({
+var initScanCompletedEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("legacy_client_path_present"),
-  removed: z9.array(z9.string())
+  event_type: z9.literal("init_scan_completed"),
+  written_stable_ids: z9.array(z9.string()),
+  duration_ms: z9.number().int().nonnegative(),
+  source: z9.enum(["init", "scan", "doctor_fix"]).optional()
 });
 var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
-  ruleContextPlannedEventSchema,
-  ruleSelectionEventSchema,
-  ruleSectionsFetchedEventSchema,
+  knowledgeContextPlannedEventSchema,
+  knowledgeSelectionEventSchema,
+  knowledgeSectionsFetchedEventSchema,
   editIntentCheckedEventSchema,
-  ruleDriftDetectedEventSchema,
-  ruleBaselineAcceptedEventSchema,
-  baselineSyncedEventSchema,
+  knowledgeDriftDetectedEventSchema,
   mcpEventLedgerEventSchema,
   reapplyCompletedEventSchema,
   eventLedgerTruncatedEventSchema,
@@ -575,29 +619,37 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   claudeSkillPathMigratedEventSchema,
   claudeHookPathMigratedEventSchema,
   codexSkillPathMigratedEventSchema,
-  legacyClientPathPresentEventSchema
+  initScanCompletedEventSchema
 ]);
 export {
   AGENTS_META_IDENTITY_SOURCES,
   AGENTS_META_LAYERS,
   AGENTS_META_TOPOLOGY_TYPES,
+  AgentsMetaCountersSchema,
+  KNOWLEDGE_TYPE_CODES,
+  KnowledgeEntryFrontmatterSchema,
+  KnowledgeTypeSchema,
+  LayerSchema,
+  MaturitySchema,
   PROTECTED_TOKENS,
   RULE_TEST_INDEX_SCHEMA_VERSION,
+  StableIdSchema,
   agentsIdentitySourceSchema,
   agentsLayerSchema,
   agentsMetaNodeSchema,
   agentsMetaSchema,
   agentsTopologyTypeSchema,
   aiLedgerEntrySchema,
+  allocateKnowledgeId,
   annotateIntentRequestSchema,
   auditModeSchema,
-  baselineSyncedEventSchema,
   candidateFileEntrySchema,
   claudeHookPathMigratedEventSchema,
   claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
   codexSkillPathMigratedEventSchema,
   createTranslator,
+  defaultAgentsMetaCounters,
   defaultMessages,
   deriveAgentsMetaIdentitySource,
   deriveAgentsMetaLayer,
@@ -621,6 +673,7 @@ export {
   forensicReportSchema,
   forensicSamplingBudgetSchema,
   forensicTopologySchema,
+  formatKnowledgeId,
   getRulesAnnotations,
   getRulesInputSchema,
   getRulesOutputSchema,
@@ -637,11 +690,16 @@ export {
   initContextInvariantSchema,
   initContextSchema,
   initContextSourceEvidenceSchema,
+  initScanCompletedEventSchema,
+  isKnowledgeStableId,
+  knowledgeContextPlannedEventSchema,
+  knowledgeDriftDetectedEventSchema,
+  knowledgeSectionsFetchedEventSchema,
+  knowledgeSelectionEventSchema,
   ledgerAppendedEventSchema,
   ledgerEntrySchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
-  legacyClientPathPresentEventSchema,
   lockApprovedEventSchema,
   lockDriftEventSchema,
   mcpConfigMigratedEventSchema,
@@ -651,20 +709,16 @@ export {
   metaReconciledOnStartupEventSchema,
   metaUpdatedEventSchema,
   normalizeLocale,
+  parseKnowledgeId,
   planContextAnnotations,
   planContextInputSchema,
   planContextOutputSchema,
   reapplyCompletedEventSchema,
-  ruleBaselineAcceptedEventSchema,
-  ruleContextPlannedEventSchema,
   ruleDescriptionIndexItemSchema,
   ruleDescriptionSchema,
-  ruleDriftDetectedEventSchema,
   ruleSectionsAnnotations,
-  ruleSectionsFetchedEventSchema,
   ruleSectionsInputSchema,
   ruleSectionsOutputSchema,
-  ruleSelectionEventSchema,
   ruleTestIndexSchema,
   ruleTestLinkSchema,
   ruleTestOrphanAnnotationSchema,

package/dist/node.js

@@ -1,6 +1,175 @@
-import {
-  detectFramework
-} from "./chunk-GI6L6VTT.js";
+// src/detector.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function detectFramework(root) {
+  const evidence = [];
+  const creatorConfigPath = join(root, "project.config.json");
+  if (existsSync(creatorConfigPath)) {
+    const version = readCreatorVersion(creatorConfigPath);
+    return {
+      kind: "cocos-creator",
+      version,
+      subkind: inferCocosSubkind(root, version),
+      evidence: version === "unknown" ? ["project.config.json"] : [`project.config.json: creator.version=${version}`],
+      framework: "cocos-creator",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["package.json", "tsconfig.json"])
+    };
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = readPackageJson(packageJsonPath);
+    const creatorVersion = packageJson.creator?.version;
+    if (typeof creatorVersion === "string" && creatorVersion.trim().length > 0) {
+      const deps2 = collectDependencyVersions(packageJson);
+      return {
+        kind: "cocos-creator",
+        version: creatorVersion,
+        subkind: inferCocosSubkind(root, creatorVersion),
+        evidence: [`package.json: creator.version=${creatorVersion}`],
+        framework: "cocos-creator",
+        confidence: "HIGH",
+        ast_evidence: [],
+        co_packages: collectCoPackages(deps2, "cocos-creator", root)
+      };
+    }
+    const deps = collectDependencyVersions(packageJson);
+    for (const [dependencyName, kind] of [
+      ["next", "next"],
+      ["vite", "vite"],
+      ["react", "react"],
+      ["vue", "vue"]
+    ]) {
+      if (deps.has(dependencyName)) {
+        const version = deps.get(dependencyName) ?? "unknown";
+        evidence.push(`package.json dependency: ${dependencyName}@${version}`);
+        return {
+          kind,
+          version,
+          subkind: inferPackageSubkind(kind),
+          evidence,
+          framework: kind,
+          confidence: determinePackageConfidence(kind, deps, root),
+          ast_evidence: [],
+          co_packages: collectCoPackages(deps, kind, root)
+        };
+      }
+    }
+    evidence.push("package.json");
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return {
+      kind: "rust",
+      version: "unknown",
+      subkind: "cargo-project",
+      evidence: ["Cargo.toml"],
+      framework: "rust",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["Cargo.lock"])
+    };
+  }
+  if (existsSync(join(root, "pyproject.toml"))) {
+    return {
+      kind: "python",
+      version: "unknown",
+      subkind: "pyproject",
+      evidence: ["pyproject.toml"],
+      framework: "python",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["uv.lock", "poetry.lock", "requirements.txt"])
+    };
+  }
+  return {
+    kind: "unknown",
+    version: "unknown",
+    subkind: "unknown",
+    evidence,
+    framework: "unknown",
+    confidence: "LOW",
+    ast_evidence: [],
+    co_packages: []
+  };
+}
+function readPackageJson(packageJsonPath) {
+  try {
+    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readCreatorVersion(creatorConfigPath) {
+  try {
+    const creatorConfig = JSON.parse(readFileSync(creatorConfigPath, "utf8"));
+    return creatorConfig.creator?.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function collectDependencyVersions(packageJson) {
+  return new Map([
+    ...Object.entries(packageJson.dependencies ?? {}),
+    ...Object.entries(packageJson.devDependencies ?? {}),
+    ...Object.entries(packageJson.peerDependencies ?? {}),
+    ...Object.entries(packageJson.optionalDependencies ?? {})
+  ]);
+}
+function inferCocosSubkind(root, version) {
+  const majorVersion = Number.parseInt(version.split(".")[0] ?? "", 10);
+  if (majorVersion === 2) {
+    return "javascript-traditional";
+  }
+  if (majorVersion >= 3) {
+    return "typescript-component";
+  }
+  return existsSync(join(root, "tsconfig.json")) ? "typescript-component" : "javascript-traditional";
+}
+function inferPackageSubkind(kind) {
+  switch (kind) {
+    case "next":
+      return "next-application";
+    case "vite":
+      return "vite-application";
+    case "react":
+      return "react-application";
+    case "vue":
+      return "vue-application";
+    default:
+      return "unknown";
+  }
+}
+function determinePackageConfidence(kind, deps, root) {
+  const coPackages = collectCoPackages(deps, kind, root);
+  return coPackages.length > 0 ? "HIGH" : "MEDIUM";
+}
+function collectCoPackages(deps, kind, root) {
+  const expectedPackagesByFramework = {
+    next: ["react", "react-dom", "typescript"],
+    vite: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "typescript", "react", "vue"],
+    react: ["react-dom", "@types/react", "@types/react-dom"],
+    vue: ["@vitejs/plugin-vue", "typescript"],
+    "cocos-creator": ["typescript"]
+  };
+  const expectedProjectFilesByFramework = {
+    next: ["next.config.js", "next.config.mjs", "next.config.ts", "tsconfig.json"],
+    vite: ["vite.config.js", "vite.config.mjs", "vite.config.ts", "tsconfig.json"],
+    react: ["tsconfig.json"],
+    vue: ["vue.config.js", "vite.config.ts", "tsconfig.json"],
+    "cocos-creator": ["project.config.json", "tsconfig.json"]
+  };
+  return [
+    ...compactStrings((expectedPackagesByFramework[kind] ?? []).map((packageName) => deps.has(packageName) ? packageName : null)),
+    ...collectProjectFileEvidence(root, expectedProjectFilesByFramework[kind] ?? [])
+  ];
+}
+function collectProjectFileEvidence(root, relativePaths) {
+  return relativePaths.filter((relativePath) => existsSync(join(root, relativePath)));
+}
+function compactStrings(values) {
+  return [...new Set(values.filter((value) => value !== null && value !== void 0 && value.length > 0))];
+}
 export {
   detectFramework
 };