@snapback/cli 1.6.0 → 3.0.0

package/dist/{chunk-RB7H4UQJ.js → chunk-7ADPL4Q3.js}

@@ -1,5 +1,7 @@
 #!/usr/bin/env node --no-warnings=ExperimentalWarning
+process.env.SNAPBACK_CLI='true';
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -7,7 +9,12 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-export { __name, __require };
-//# sourceMappingURL=chunk-RB7H4UQJ.js.map
-//# sourceMappingURL=chunk-RB7H4UQJ.js.map
+export { __commonJS, __export, __name, __require };

package/dist/chunk-CBGOC6RV.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { __name } from './chunk-7ADPL4Q3.js';
+import { z } from 'zod';
+
+process.env.SNAPBACK_CLI='true';
+var LearningTypeSchema = z.enum([
+  "pattern",
+  "pitfall",
+  "efficiency",
+  "workflow",
+  "discovery"
+]);
+var LearningIntentSchema = z.enum([
+  "implement",
+  "debug",
+  "refactor",
+  "review"
+]);
+z.enum([
+  "add-flag",
+  "set-env",
+  "inject-validation",
+  "warn",
+  "suggest-file"
+]);
+var WarnSeveritySchema = z.enum([
+  "info",
+  "warning",
+  "error"
+]);
+var AddFlagPayloadSchema = z.object({
+  flag: z.string().min(1).describe("CLI flag to add, e.g. '--validate-expiry'"),
+  value: z.union([
+    z.string(),
+    z.boolean()
+  ]).optional().describe("Flag value if applicable"),
+  reason: z.string().min(1).describe("Human-readable reason shown in verbose mode")
+});
+var SetEnvPayloadSchema = z.object({
+  key: z.string().min(1).regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name"),
+  value: z.string().describe("Environment variable value"),
+  reason: z.string().min(1).describe("Human-readable reason shown in verbose mode")
+});
+var InjectValidationPayloadSchema = z.object({
+  validationType: z.string().min(1).describe("Validation type identifier, e.g. 'jwt-expiry', 'silent-catch'"),
+  targetFile: z.string().optional().describe("Optional file to target for validation"),
+  reason: z.string().min(1).describe("Human-readable reason shown in verbose mode")
+});
+var WarnPayloadSchema = z.object({
+  message: z.string().min(1).describe("Warning message to display"),
+  severity: WarnSeveritySchema.describe("Severity level affects display styling")
+});
+var SuggestFilePayloadSchema = z.object({
+  filePath: z.string().min(1).describe("Suggested file path, may contain {feature} placeholder"),
+  reason: z.string().min(1).describe("Human-readable reason for suggestion")
+});
+var LearningTriggerSchema = z.object({
+  commands: z.array(z.string()).optional().describe("Command names that trigger this learning, e.g. ['auth', 'deploy']"),
+  intent: z.array(LearningIntentSchema).optional().describe("Intent types that trigger this learning"),
+  filePatterns: z.array(z.string()).optional().describe("Glob patterns for file matching, e.g. ['**/*auth*.ts']"),
+  flags: z.array(z.string()).optional().describe("CLI flags that trigger this learning, e.g. ['--provider']"),
+  description: z.string().min(1).describe("Human-readable description for fuzzy matching")
+});
+var LearningActionSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("add-flag"),
+    payload: AddFlagPayloadSchema
+  }),
+  z.object({
+    type: z.literal("set-env"),
+    payload: SetEnvPayloadSchema
+  }),
+  z.object({
+    type: z.literal("inject-validation"),
+    payload: InjectValidationPayloadSchema
+  }),
+  z.object({
+    type: z.literal("warn"),
+    payload: WarnPayloadSchema
+  }),
+  z.object({
+    type: z.literal("suggest-file"),
+    payload: SuggestFilePayloadSchema
+  })
+]);
+var LearningSchema = z.object({
+  id: z.string().min(1).describe("Unique identifier for this learning"),
+  type: LearningTypeSchema.describe("Categorical classification"),
+  trigger: LearningTriggerSchema.describe("Conditions that activate this learning"),
+  action: LearningActionSchema.describe("Concrete action to execute"),
+  confidence: z.number().min(0).max(1).describe("Confidence score (0.0-1.0), static at creation"),
+  created: z.number().int().positive().describe("Creation timestamp (ms since epoch)"),
+  lastUsed: z.number().int().positive().optional().describe("Last usage timestamp (ms since epoch)"),
+  usageCount: z.number().int().nonnegative().default(0).describe("Number of times this learning was applied"),
+  tags: z.array(z.string()).default([]).describe("Searchable tags for categorization"),
+  archived: z.boolean().default(false).describe("Whether this learning is archived (excluded from matching)")
+});
+LearningSchema.omit({
+  id: true,
+  created: true,
+  lastUsed: true,
+  usageCount: true,
+  archived: true
+}).extend({
+  tags: z.array(z.string()).optional().default([]),
+  archived: z.boolean().optional()
+});
+z.enum([
+  "observe",
+  "warn",
+  "apply-safe",
+  "apply-all",
+  "off"
+]);
+z.object({
+  workspaceId: z.string().min(1),
+  startedAt: z.number().int().positive(),
+  lastCommandAt: z.number().int().positive(),
+  appliedLearnings: z.array(z.string()).describe("Learning IDs applied in this session")
+});
+z.object({
+  workspaceId: z.string().min(1),
+  commandName: z.string().min(1),
+  args: z.record(z.unknown()).optional().describe("Parsed command arguments/flags"),
+  filesOrPaths: z.array(z.string()).optional().describe("Files involved in command"),
+  intent: LearningIntentSchema.optional().describe("User intent if known")
+});
+var SelectedLearningSchema = z.object({
+  id: z.string(),
+  title: z.string().describe("Human-readable title derived from trigger.description"),
+  type: LearningTypeSchema,
+  score: z.number().min(0).max(1),
+  action: LearningActionSchema,
+  tags: z.array(z.string())
+});
+z.object({
+  selectedLearnings: z.array(SelectedLearningSchema),
+  debug: z.object({
+    evaluatedCount: z.number().int().nonnegative(),
+    durationMs: z.number().nonnegative(),
+    skippedReason: z.string().optional()
+  }).optional()
+});
+var LearningTierSchema = z.enum([
+  "hot",
+  "warm",
+  "cold"
+]);
+var LearningPrioritySchema = z.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var LearningStorageTypeSchema = z.enum([
+  "pattern",
+  "pitfall",
+  "pit",
+  "architecture",
+  "performance",
+  "efficiency",
+  "discovery",
+  "workflow",
+  "best-practice"
+]);
+var LearningStorageSchema = z.object({
+  id: z.string().min(1).optional(),
+  type: LearningStorageTypeSchema,
+  trigger: z.union([
+    z.string(),
+    z.array(z.string())
+  ]),
+  context: z.string().optional(),
+  problem: z.string().optional(),
+  solution: z.string().optional(),
+  action: z.string(),
+  related: z.array(z.string()).optional(),
+  source: z.string(),
+  timestamp: z.union([
+    z.string(),
+    z.number()
+  ]).describe("ISO 8601 string or epoch number from storage"),
+  // Tiering metadata (optional)
+  tier: LearningTierSchema.optional(),
+  domain: z.string().optional(),
+  priority: LearningPrioritySchema.optional(),
+  keywords: z.array(z.string()).optional(),
+  // Usage tracking (optional)
+  accessCount: z.number().int().nonnegative().optional(),
+  lastAccessed: z.string().optional(),
+  relevanceScore: z.number().min(0).max(1).optional(),
+  appliedDate: z.string().optional()
+});
+var ChunkSourceTypeSchema = z.enum([
+  "learning",
+  "adr",
+  "pattern",
+  "violation"
+]);
+var ChunkStatusSchema = z.enum([
+  "active",
+  "deprecated",
+  "superseded"
+]);
+z.object({
+  id: z.string().describe("Unique chunk identifier"),
+  source_type: ChunkSourceTypeSchema.describe("Type of source this chunk came from"),
+  source_id: z.string().describe("ID of the source record"),
+  chunk_text: z.string().describe("The actual content text"),
+  context_text: z.string().optional().describe("Optional context surrounding the chunk"),
+  authority: z.number().min(0).max(1).describe("Authority score (0-1)"),
+  status: ChunkStatusSchema.describe("Current status of the chunk"),
+  created_at: z.string().describe("ISO 8601 creation timestamp"),
+  updated_at: z.string().describe("ISO 8601 update timestamp"),
+  metadata: z.record(z.unknown()).optional().describe("Optional JSON metadata")
+});
+var OutcomeTypeSchema = z.enum([
+  "accepted",
+  "ignored",
+  "test_pass",
+  "test_fail",
+  "violation_prevented"
+]);
+z.object({
+  id: z.string(),
+  chunk_id: z.string(),
+  outcome_type: OutcomeTypeSchema,
+  context: z.record(z.unknown()).optional(),
+  created_at: z.string()
+});
+var LearningApiSchema = z.object({
+  id: z.string().min(1).describe("Unique identifier"),
+  type: LearningTypeSchema.describe("Categorical classification"),
+  trigger: z.string().describe("Normalized trigger condition"),
+  action: z.string().describe("Action to take (human-readable)"),
+  confidence: z.number().min(0).max(1).describe("Confidence score (0.0-1.0)"),
+  created: z.number().int().positive().describe("Creation timestamp (ms since epoch)"),
+  source: z.string().describe("Where this learning originated"),
+  tags: z.array(z.string()).default([]).describe("Searchable tags"),
+  usageCount: z.number().int().nonnegative().default(0).describe("Times applied")
+});
+function normalizeLearningType(type) {
+  switch (type) {
+    case "pattern":
+      return "pattern";
+    case "pitfall":
+    case "pit":
+      return "pitfall";
+    case "efficiency":
+    case "performance":
+      return "efficiency";
+    case "workflow":
+    case "best-practice":
+      return "workflow";
+    case "discovery":
+      return "discovery";
+    case "architecture":
+      return "pattern";
+    // Architecture patterns map to pattern
+    default: {
+      return "pattern";
+    }
+  }
+}
+__name(normalizeLearningType, "normalizeLearningType");
+function elevateLearningToApi(storage, options) {
+  const id = storage.id ?? `learning-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  const normalizedType = normalizeLearningType(storage.type);
+  const trigger = Array.isArray(storage.trigger) ? storage.trigger.join(", ") : storage.trigger;
+  let created;
+  if (typeof storage.timestamp === "string") {
+    const parsed = new Date(storage.timestamp);
+    created = Number.isNaN(parsed.getTime()) ? Date.now() : parsed.getTime();
+  } else {
+    created = storage.timestamp;
+  }
+  const confidence = storage.relevanceScore ?? (options?.relevanceBoost ?? 0.7) * (storage.accessCount ? Math.min(1, storage.accessCount / 10) : 0.5);
+  return {
+    id,
+    type: normalizedType,
+    trigger,
+    action: storage.action,
+    confidence: Math.round(confidence * 1e3) / 1e3,
+    created,
+    source: storage.source,
+    tags: storage.keywords ?? [],
+    usageCount: storage.accessCount ?? 0
+  };
+}
+__name(elevateLearningToApi, "elevateLearningToApi");
+LearningStorageSchema.transform((storage) => elevateLearningToApi(storage)).pipe(LearningApiSchema);
+
+export { LearningApiSchema };