@fenglimg/fabric-shared 1.6.0 → 1.8.0-rc.1

package/dist/chunk-KV27CZH3.js

@@ -0,0 +1,223 @@
+// src/schemas/api-contracts.ts
+import { z } from "zod";
+var structuredWarningSchema = z.object({
+  code: z.string(),
+  file: z.string(),
+  line: z.number().optional(),
+  action_hint: z.string()
+});
+var _ruleDescriptionSchema = z.object({
+  summary: z.string(),
+  intent_clues: z.array(z.string()),
+  tech_stack: z.array(z.string()),
+  impact: z.array(z.string()),
+  must_read_if: z.string(),
+  entities: z.array(z.string()).optional()
+});
+var _descriptionIndexItemSchema = z.object({
+  stable_id: z.string(),
+  level: z.enum(["L0", "L1", "L2"]),
+  required: z.boolean(),
+  selectable: z.boolean(),
+  description: _ruleDescriptionSchema
+});
+var _requirementProfileSchema = z.object({
+  target_path: z.string(),
+  path_segments: z.array(z.string()),
+  extension: z.string(),
+  inferred_domain: z.array(z.string()),
+  known_tech: z.array(z.string()),
+  user_intent: z.string(),
+  intent_tokens: z.array(z.string()),
+  impact_hints: z.array(z.string()),
+  detected_entities: z.array(z.string())
+});
+var _selectionPolicySchema = z.object({
+  required_levels: z.tuple([z.literal("L0"), z.literal("L2")]),
+  ai_selectable_levels: z.tuple([z.literal("L1")]),
+  final_fetch_rule: z.literal("required_stable_ids + ai_selected_l1_stable_ids")
+});
+var planContextInputSchema = z.object({
+  paths: z.array(z.string()).min(1).describe("Candidate file paths to build neutral rule selection context for"),
+  intent: z.string().optional().describe("User-stated requirement or implementation intent; used only to build a neutral requirement profile"),
+  known_tech: z.array(z.string()).optional().describe("Known technologies involved in the requirement profile"),
+  detected_entities: z.record(z.array(z.string())).optional().describe("Optional path-keyed detected entities for the requirement profile"),
+  client_hash: z.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
+});
+var planContextOutputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  selection_token: z.string(),
+  entries: z.array(
+    z.object({
+      path: z.string(),
+      requirement_profile: _requirementProfileSchema,
+      description_index: z.array(_descriptionIndexItemSchema),
+      required_stable_ids: z.array(z.string()),
+      ai_selectable_stable_ids: z.array(z.string()),
+      initial_selected_stable_ids: z.array(z.string()),
+      selection_policy: _selectionPolicySchema
+    })
+  ),
+  shared: z.object({
+    required_stable_ids: z.array(z.string()),
+    ai_selectable_stable_ids: z.array(z.string()),
+    description_index: z.array(_descriptionIndexItemSchema),
+    preflight_diagnostics: z.array(
+      z.object({
+        code: z.literal("missing_description"),
+        severity: z.literal("warn"),
+        message: z.string(),
+        stable_ids: z.array(z.string()).optional(),
+        path: z.string().optional()
+      })
+    )
+  }),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var planContextAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Plan rule context"
+};
+var _rulesEntrySchema = z.object({ path: z.string(), content: z.string() });
+var _humanLockedSchema = z.object({ file: z.string(), excerpt: z.string() });
+var _descriptionStubSchema = z.object({ path: z.string(), description: z.string() });
+var getRulesInputSchema = z.object({
+  path: z.string().describe("Target file path to query rules for"),
+  client_hash: z.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
+});
+var getRulesOutputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  rules: z.object({
+    L0: z.string(),
+    L1: z.array(_rulesEntrySchema),
+    L2: z.array(_rulesEntrySchema),
+    human_locked_nearby: z.array(_humanLockedSchema),
+    description_stubs: z.array(_descriptionStubSchema).optional()
+  }),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var getRulesAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Get rule content"
+};
+var RULE_SECTION_NAMES_TUPLE = ["MISSION_STATEMENT", "MANDATORY_INJECTION", "BUSINESS_LOGIC_CHUNKS", "CONTEXT_INFO"];
+var ruleSectionsInputSchema = z.object({
+  selection_token: z.string().min(1).describe("Selection token returned by fab_plan_context"),
+  sections: z.array(z.enum(RULE_SECTION_NAMES_TUPLE)).min(1).describe("Structured rule sections to fetch"),
+  ai_selected_stable_ids: z.array(z.string()).describe("AI-selected L1 stable_ids chosen from fab_plan_context ai_selectable_stable_ids"),
+  ai_selection_reasons: z.record(z.string().min(1)).describe("Reason for each AI-selected L1 stable_id"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
+});
+var ruleSectionsOutputSchema = z.object({
+  revision_hash: z.string(),
+  precedence: z.tuple([z.literal("L2"), z.literal("L1"), z.literal("L0")]),
+  selected_stable_ids: z.array(z.string()),
+  rules: z.array(
+    z.object({
+      stable_id: z.string(),
+      level: z.enum(["L0", "L1", "L2"]),
+      path: z.string(),
+      sections: z.record(z.string())
+    })
+  ),
+  diagnostics: z.array(
+    z.object({
+      code: z.literal("missing_section"),
+      severity: z.literal("warn"),
+      stable_id: z.string(),
+      section: z.enum(RULE_SECTION_NAMES_TUPLE),
+      message: z.string()
+    })
+  ),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var ruleSectionsAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Filter rule sections"
+};
+var ledgerSourceSchema = z.enum(["ai", "human"]);
+var timestampFilterSchema = z.preprocess((value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return Number.parseInt(trimmed, 10);
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  return value;
+}, z.number().int().nonnegative());
+var ledgerQuerySchema = z.object({
+  source: ledgerSourceSchema.optional(),
+  since: timestampFilterSchema.optional()
+});
+var historyStateQuerySchema = z.object({
+  ledger_id: z.string().trim().min(1).optional(),
+  ts: timestampFilterSchema.optional()
+}).superRefine((value, ctx) => {
+  const provided = [value.ledger_id, value.ts].filter((entry) => entry !== void 0);
+  if (provided.length !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provide exactly one of ledger_id or ts.",
+      path: ["ledger_id"]
+    });
+  }
+});
+var humanLockApproveRequestSchema = z.object({
+  file: z.string().min(1),
+  start_line: z.number().int().positive(),
+  end_line: z.number().int().positive(),
+  new_hash: z.string().min(1)
+});
+var humanLockFileParamsSchema = z.object({
+  file: z.string().min(1)
+});
+var annotateIntentRequestSchema = z.object({
+  ledger_entry_id: z.string().min(1),
+  annotation: z.string().trim().min(1)
+});
+
+export {
+  structuredWarningSchema,
+  planContextInputSchema,
+  planContextOutputSchema,
+  planContextAnnotations,
+  getRulesInputSchema,
+  getRulesOutputSchema,
+  getRulesAnnotations,
+  ruleSectionsInputSchema,
+  ruleSectionsOutputSchema,
+  ruleSectionsAnnotations,
+  ledgerSourceSchema,
+  ledgerQuerySchema,
+  historyStateQuerySchema,
+  humanLockApproveRequestSchema,
+  humanLockFileParamsSchema,
+  annotateIntentRequestSchema
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,65 @@
+declare abstract class FabricError extends Error {
+    abstract readonly code: string;
+    readonly actionHint: string;
+    readonly fixable: boolean;
+    readonly details?: unknown;
+    abstract readonly httpStatus: number;
+    constructor(message: string, opts: {
+        actionHint: string;
+        fixable?: boolean;
+        details?: unknown;
+    });
+    toJSON(): {
+        details?: {} | null | undefined;
+        name: string;
+        code: string;
+        message: string;
+        actionHint: string;
+        fixable: boolean;
+    };
+}
+
+declare abstract class ConfigError extends FabricError {
+    readonly httpStatus = 400;
+}
+declare class ConfigPathInvalidError extends ConfigError {
+    readonly code = "config_path_invalid";
+}
+declare class GenericConfigError extends ConfigError {
+    readonly code = "config_error";
+}
+
+declare abstract class RuleError extends FabricError {
+    readonly httpStatus: number;
+}
+declare class RuleValidationError extends RuleError {
+    readonly code = "rule_validation_error";
+}
+
+declare abstract class IOFabricError extends FabricError {
+    readonly httpStatus: number;
+}
+declare class PathEscapeError extends IOFabricError {
+    readonly code = "PATH_OUTSIDE_PROJECT_ROOT";
+    readonly httpStatus = 403;
+}
+declare class GenericIOError extends IOFabricError {
+    readonly code = "io_error";
+}
+
+declare abstract class MCPError extends FabricError {
+    abstract readonly httpStatus: number;
+}
+declare class McpToolError extends MCPError {
+    readonly code = "mcp_tool_error";
+    readonly httpStatus = 500;
+}
+
+declare abstract class InitError extends FabricError {
+    readonly httpStatus = 500;
+}
+declare class InitFrameworkUnknownError extends InitError {
+    readonly code = "init_framework_unknown";
+}
+
+export { ConfigError, ConfigPathInvalidError, FabricError, GenericConfigError, GenericIOError, IOFabricError, InitError, InitFrameworkUnknownError, MCPError, McpToolError, PathEscapeError, RuleError, RuleValidationError };

package/dist/errors/index.js

@@ -0,0 +1,30 @@
+import {
+  ConfigError,
+  ConfigPathInvalidError,
+  FabricError,
+  GenericConfigError,
+  GenericIOError,
+  IOFabricError,
+  InitError,
+  InitFrameworkUnknownError,
+  MCPError,
+  McpToolError,
+  PathEscapeError,
+  RuleError,
+  RuleValidationError
+} from "../chunk-3SZRB42B.js";
+export {
+  ConfigError,
+  ConfigPathInvalidError,
+  FabricError,
+  GenericConfigError,
+  GenericIOError,
+  IOFabricError,
+  InitError,
+  InitFrameworkUnknownError,
+  MCPError,
+  McpToolError,
+  PathEscapeError,
+  RuleError,
+  RuleValidationError
+};

package/dist/i18n/index.d.ts

@@ -12,7 +12,7 @@ declare function detectNodeLocale(): Locale;
 
 declare function normalizeLocale(raw: string | null | undefined): Locale;
 
-declare const PROTECTED_TOKENS: readonly ["fab_get_rules", "fab_append_intent", "fab_update_registry", "fabric_rules", "ledger_entry", "ledger_entry_id", "agent_meta", "AGENTS.md", "FABRIC.md", ".fabric/agents/", ".fabric/agents/_cross/", ".fabric/agents.meta.json", ".fabric/human-lock.json", ".fabric/init-context.json", ".fabric/forensic.json", ".fabric/.intent-ledger.jsonl", "@HUMAN", "shadow constraints", "Shadow Mirroring", "CORE RULES", "DO NOT TRANSLATE", "MUST", "NEVER"];
+declare const PROTECTED_TOKENS: readonly ["fab_plan_context", "fab_get_rule_sections", "fabric_rules", "ledger_entry", "ledger_entry_id", "agent_meta", "AGENTS.md", "FABRIC.md", ".fabric/agents/", ".fabric/agents/_cross/", ".fabric/agents.meta.json", ".fabric/human-lock.json", ".fabric/init-context.json", ".fabric/forensic.json", ".fabric/.intent-ledger.jsonl", ".fabric/events.jsonl", "@HUMAN", "shadow constraints", "Shadow Mirroring", "CORE RULES", "DO NOT TRANSLATE", "MUST", "NEVER"];
 type ProtectedToken = (typeof PROTECTED_TOKENS)[number];
 
 declare const enMessages: Messages;

package/dist/i18n/index.js

@@ -6,7 +6,7 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "../chunk-KNZIX6IL.js";
+} from "../chunk-7A3RSITZ.js";
 export {
   PROTECTED_TOKENS,
   createTranslator,