@prave/shared 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './schemas/index.js';
 export * from './types/index.js';
+export * from './lib/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './schemas/index.js';
 export * from './types/index.js';
+export * from './lib/index.js';

package/dist/lib/classify.d.ts

@@ -0,0 +1,21 @@
+import type { SkillCategory } from '@prave/shared';
+/**
+ * Pull a yaml `category:` value out of SKILL.md frontmatter. Returns null
+ * when no frontmatter, no `category` key, or value isn't in the enum.
+ */
+export declare function extractCategoryFromFrontmatter(content: string): SkillCategory | null;
+/**
+ * Pull a yaml `description:` from SKILL.md frontmatter, if present. Used by
+ * the import path so frontmatter authors don't pay for AI generation.
+ */
+export declare function extractDescriptionFromFrontmatter(content: string): string | null;
+/**
+ * Classify a skill by frontmatter first, then by keyword score, then 'other'.
+ * Caller should still allow the user to override before insert.
+ */
+export declare function classifySkill(opts: {
+    name?: string | null;
+    description?: string | null;
+    content?: string | null;
+}): SkillCategory;
+//# sourceMappingURL=classify.d.ts.map

package/dist/lib/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/lib/classify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAyClD;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CASpF;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAShF;AAkDD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB,GAAG,aAAa,CAmBhB"}

package/dist/lib/classify.js

@@ -0,0 +1,121 @@
+const RULES = [
+    { category: 'engineering', keywords: /\b(typescript|react|api|backend|frontend|database|sql|component|refactor|build|deploy|library|framework|debug|test runner)\b/i },
+    { category: 'devops', keywords: /\b(docker|kubernetes|k8s|ci\/cd|pipeline|terraform|ansible|helm|nginx|caddy|reverse proxy|deployment|infrastructure)\b/i },
+    { category: 'security', keywords: /\b(auth|jwt|oauth|xss|csrf|rbac|encryption|vulnerab|pentest|threat|owasp|sanitize|escape)\b/i },
+    { category: 'data', keywords: /\b(etl|airflow|warehouse|snowflake|bigquery|pipeline|ingest|elasticsearch|postgres|mongodb|redis)\b/i },
+    { category: 'ai', keywords: /\b(claude|gpt|llm|prompt|embedding|rag|tokeniz|fine[- ]?tune|inference|anthropic|openai|hugging.?face|model|agent)\b/i },
+    { category: 'design', keywords: /\b(ui|ux|figma|wireframe|mockup|color palette|typography|spacing|layout|brand|visual|prototype|usability)\b/i },
+    { category: 'marketing', keywords: /\b(seo|sem|cro|conversion|funnel|landing page|copywriting|ad creative|paid ads|email marketing|growth|campaign|outreach|social media|trustpilot|cold email|lead magnet)\b/i },
+    { category: 'analytics', keywords: /\b(analytics|metrics|dashboard|kpi|cohort|retention|attribution|event tracking|mixpanel|amplitude|posthog|ga4|google analytics)\b/i },
+    { category: 'research', keywords: /\b(research|interview|survey|user testing|persona|hypothesis|experiment|methodology|literature review|customer development)\b/i },
+    { category: 'writing', keywords: /\b(write|writing|edit|editorial|tone of voice|narrative|story|blog post|copy[- ]?edit|grammar|style guide|proofread)\b/i },
+    { category: 'product', keywords: /\b(product[- ]?management|roadmap|backlog|user story|epic|requirement|spec(ification)?|feature flag|prd|stakeholder|prioriti[zs]ation|jira|linear)\b/i },
+    { category: 'productivity', keywords: /\b(productivity|workflow|automation|task management|todo|note[- ]?taking|knowledge base|second brain|gtd|focus|inbox)\b/i },
+    { category: 'workflow-orchestration', keywords: /\b(orchestrat|workflow engine|state machine|saga|step function|temporal|n8n|zapier|airflow dag|orchestration)\b/i },
+];
+const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---/;
+const FALLBACK = 'other';
+/**
+ * Pull a yaml `category:` value out of SKILL.md frontmatter. Returns null
+ * when no frontmatter, no `category` key, or value isn't in the enum.
+ */
+export function extractCategoryFromFrontmatter(content) {
+    const match = FRONTMATTER_RE.exec(content);
+    if (!match)
+        return null;
+    const fm = match[1];
+    if (!fm)
+        return null;
+    const line = fm.split('\n').find((l) => /^\s*category\s*:/i.test(l));
+    if (!line)
+        return null;
+    const raw = line.split(':').slice(1).join(':').trim().replace(/^['"]|['"]$/g, '').toLowerCase();
+    return normalizeCategory(raw);
+}
+/**
+ * Pull a yaml `description:` from SKILL.md frontmatter, if present. Used by
+ * the import path so frontmatter authors don't pay for AI generation.
+ */
+export function extractDescriptionFromFrontmatter(content) {
+    const match = FRONTMATTER_RE.exec(content);
+    if (!match)
+        return null;
+    const fm = match[1];
+    if (!fm)
+        return null;
+    const line = fm.split('\n').find((l) => /^\s*description\s*:/i.test(l));
+    if (!line)
+        return null;
+    const raw = line.split(':').slice(1).join(':').trim().replace(/^['"]|['"]$/g, '');
+    return raw.length >= 12 ? raw.slice(0, 280) : null;
+}
+const ALIASES = {
+    dev: 'engineering',
+    software: 'engineering',
+    coding: 'engineering',
+    programming: 'engineering',
+    ml: 'ai',
+    llm: 'ai',
+    ops: 'devops',
+    infra: 'devops',
+    infrastructure: 'devops',
+    ux: 'design',
+    ui: 'design',
+    growth: 'marketing',
+    copywriting: 'writing',
+    copy: 'writing',
+    pm: 'product',
+    'product-management': 'product',
+};
+function normalizeCategory(raw) {
+    if (!raw)
+        return null;
+    const key = raw.toLowerCase().trim();
+    const aliased = ALIASES[key];
+    if (aliased)
+        return aliased;
+    // Direct match against the enum literals.
+    if ([
+        'engineering',
+        'design',
+        'marketing',
+        'research',
+        'writing',
+        'analytics',
+        'productivity',
+        'devops',
+        'data',
+        'ai',
+        'security',
+        'product',
+        'workflow-orchestration',
+        'other',
+    ].includes(key)) {
+        return key;
+    }
+    return null;
+}
+/**
+ * Classify a skill by frontmatter first, then by keyword score, then 'other'.
+ * Caller should still allow the user to override before insert.
+ */
+export function classifySkill(opts) {
+    const text = [opts.name ?? '', opts.description ?? '', opts.content ?? ''].join('\n');
+    if (opts.content) {
+        const fm = extractCategoryFromFrontmatter(opts.content);
+        if (fm)
+            return fm;
+    }
+    let bestCategory = FALLBACK;
+    let bestScore = 0;
+    for (const rule of RULES) {
+        const matches = text.match(new RegExp(rule.keywords.source, 'gi'));
+        const score = matches ? matches.length : 0;
+        if (score > bestScore) {
+            bestScore = score;
+            bestCategory = rule.category;
+        }
+    }
+    // Require at least 2 keyword hits before committing — single hits are noisy.
+    return bestScore >= 2 ? bestCategory : FALLBACK;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classify.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/lib/index.js

@@ -0,0 +1 @@
+export * from './classify.js';

package/dist/schemas/api-keys.schema.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export declare const aiProviderSchema: z.ZodEnum<["anthropic", "openai", "gemini"]>;
+export type AiProvider = z.infer<typeof aiProviderSchema>;
+export declare const AI_PROVIDER_LABELS: Record<AiProvider, string>;
+export declare const setApiKeyInputSchema: z.ZodObject<{
+    provider: z.ZodEnum<["anthropic", "openai", "gemini"]>;
+    api_key: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    provider: "gemini" | "anthropic" | "openai";
+    api_key: string;
+    label?: string | undefined;
+}, {
+    provider: "gemini" | "anthropic" | "openai";
+    api_key: string;
+    label?: string | undefined;
+}>;
+export type SetApiKeyInput = z.infer<typeof setApiKeyInputSchema>;
+export interface UserApiKeyView {
+    id: string;
+    provider: AiProvider;
+    last4: string;
+    label: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export declare const aiCompleteInputSchema: z.ZodObject<{
+    provider: z.ZodEnum<["anthropic", "openai", "gemini"]>;
+    before: z.ZodString;
+    after: z.ZodOptional<z.ZodString>;
+    file_type: z.ZodDefault<z.ZodEnum<["md", "json", "ts", "js", "yaml", "plain"]>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "gemini" | "anthropic" | "openai";
+    before: string;
+    file_type: "md" | "json" | "ts" | "js" | "yaml" | "plain";
+    after?: string | undefined;
+}, {
+    provider: "gemini" | "anthropic" | "openai";
+    before: string;
+    after?: string | undefined;
+    file_type?: "md" | "json" | "ts" | "js" | "yaml" | "plain" | undefined;
+}>;
+export type AiCompleteInput = z.infer<typeof aiCompleteInputSchema>;
+export declare const aiGenerateInputSchema: z.ZodObject<{
+    provider: z.ZodEnum<["anthropic", "openai", "gemini"]>;
+    prompt: z.ZodString;
+    /** Existing skill content the user is iterating on. */
+    existing_content: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    provider: "gemini" | "anthropic" | "openai";
+    existing_content?: string | undefined;
+}, {
+    prompt: string;
+    provider: "gemini" | "anthropic" | "openai";
+    existing_content?: string | undefined;
+}>;
+export type AiGenerateInput = z.infer<typeof aiGenerateInputSchema>;
+export interface AiCompleteResult {
+    completion: string;
+    /** Tokens consumed if the provider reports them. */
+    input_tokens?: number;
+    output_tokens?: number;
+}
+export interface AiGenerateResult {
+    /** Full SKILL.md body the editor should drop into the buffer. */
+    content: string;
+    input_tokens?: number;
+    output_tokens?: number;
+}
+//# sourceMappingURL=api-keys.schema.d.ts.map

package/dist/schemas/api-keys.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-keys.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/api-keys.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB,8CAA4C,CAAA;AACzE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAIzD,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAQ/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,UAAU,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAID,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB;;;IAGhC,uDAAuD;;;;;;;;;;EAEvD,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB"}

package/dist/schemas/api-keys.schema.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const aiProviderSchema = z.enum(['anthropic', 'openai', 'gemini']);
+export const AI_PROVIDER_LABELS = {
+    anthropic: 'Claude (Anthropic)',
+    openai: 'OpenAI',
+    gemini: 'Google Gemini',
+};
+export const setApiKeyInputSchema = z.object({
+    provider: aiProviderSchema,
+    api_key: z
+        .string()
+        .min(8, 'API key looks too short')
+        .max(400, 'API key looks too long')
+        .trim(),
+    label: z.string().max(80).optional(),
+});
+/* ── In-editor AI assistant ─────────────────────────────────────────── */
+export const aiCompleteInputSchema = z.object({
+    provider: aiProviderSchema,
+    before: z.string().max(8000),
+    after: z.string().max(2000).optional(),
+    file_type: z.enum(['md', 'json', 'ts', 'js', 'yaml', 'plain']).default('md'),
+});
+export const aiGenerateInputSchema = z.object({
+    provider: aiProviderSchema,
+    prompt: z.string().min(8).max(4000),
+    /** Existing skill content the user is iterating on. */
+    existing_content: z.string().max(50_000).optional(),
+});

package/dist/schemas/credits.schema.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/**
+ * Credit-pack catalog. One-time purchases that top up
+ * `profiles.tester_credits_balance`. Prices target a ≥40% gross margin
+ * over Haiku 4.5 worst-case usage (~€0.015/credit).
+ */
+export declare const CREDIT_PACK_IDS: readonly ["pack_25", "pack_100"];
+export declare const creditPackIdSchema: z.ZodEnum<["pack_25", "pack_100"]>;
+export type CreditPackId = z.infer<typeof creditPackIdSchema>;
+export interface CreditPack {
+    id: CreditPackId;
+    credits: number;
+    /** Gross price in EUR (VAT-inclusive — Stripe Tax computes the net split). */
+    price_eur: number;
+    /** Best-for hint shown on the pack card. */
+    blurb: string;
+}
+/**
+ * Two top-up tiers — entry and refill. Per-credit price is intentionally
+ * kept *higher* than every paid subscription so power users always come
+ * out ahead by upgrading instead of hoarding packs. A single big pack
+ * tier was tested and dropped: it created subscription cannibalisation
+ * (Creator @ €0.040/credit vs a hypothetical 500-pack @ €0.038/credit)
+ * and one-shot LTV with months of dormancy.
+ */
+export declare const CREDIT_PACKS: Record<CreditPackId, CreditPack>;
+export declare const creditCheckoutInputSchema: z.ZodObject<{
+    pack: z.ZodEnum<["pack_25", "pack_100"]>;
+}, "strip", z.ZodTypeAny, {
+    pack: "pack_25" | "pack_100";
+}, {
+    pack: "pack_25" | "pack_100";
+}>;
+export type CreditCheckoutInput = z.infer<typeof creditCheckoutInputSchema>;
+export declare const creditBalanceSchema: z.ZodObject<{
+    monthly_quota: z.ZodNumber;
+    monthly_used: z.ZodNumber;
+    monthly_remaining: z.ZodNumber;
+    /** Purchased top-up balance (never expires). */
+    balance: z.ZodNumber;
+    /** Total credits available right now (monthly_remaining + balance). */
+    total_available: z.ZodNumber;
+    /** ISO timestamp when the monthly window resets. */
+    resets_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    monthly_quota: number;
+    monthly_used: number;
+    monthly_remaining: number;
+    balance: number;
+    total_available: number;
+    resets_at: string;
+}, {
+    monthly_quota: number;
+    monthly_used: number;
+    monthly_remaining: number;
+    balance: number;
+    total_available: number;
+    resets_at: string;
+}>;
+export type CreditBalance = z.infer<typeof creditBalanceSchema>;
+//# sourceMappingURL=credits.schema.d.ts.map

package/dist/schemas/credits.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credits.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/credits.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,eAAe,kCAAmC,CAAA;AAC/D,eAAO,MAAM,kBAAkB,oCAA0B,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,YAAY,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAA;IACjB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAazD,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;EAEpC,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,mBAAmB;;;;IAI9B,gDAAgD;;IAEhD,uEAAuE;;IAEvE,oDAAoD;;;;;;;;;;;;;;;;EAEpD,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schemas/credits.schema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+/**
+ * Credit-pack catalog. One-time purchases that top up
+ * `profiles.tester_credits_balance`. Prices target a ≥40% gross margin
+ * over Haiku 4.5 worst-case usage (~€0.015/credit).
+ */
+export const CREDIT_PACK_IDS = ['pack_25', 'pack_100'];
+export const creditPackIdSchema = z.enum(CREDIT_PACK_IDS);
+/**
+ * Two top-up tiers — entry and refill. Per-credit price is intentionally
+ * kept *higher* than every paid subscription so power users always come
+ * out ahead by upgrading instead of hoarding packs. A single big pack
+ * tier was tested and dropped: it created subscription cannibalisation
+ * (Creator @ €0.040/credit vs a hypothetical 500-pack @ €0.038/credit)
+ * and one-shot LTV with months of dormancy.
+ */
+export const CREDIT_PACKS = {
+    pack_25: {
+        id: 'pack_25',
+        credits: 25,
+        price_eur: 2,
+        blurb: 'Quick top-up when you hit the wall.',
+    },
+    pack_100: {
+        id: 'pack_100',
+        credits: 100,
+        price_eur: 6,
+        blurb: 'Best value for active builders.',
+    },
+};
+export const creditCheckoutInputSchema = z.object({
+    pack: creditPackIdSchema,
+});
+export const creditBalanceSchema = z.object({
+    monthly_quota: z.number().int().nonnegative(),
+    monthly_used: z.number().int().nonnegative(),
+    monthly_remaining: z.number().int().nonnegative(),
+    /** Purchased top-up balance (never expires). */
+    balance: z.number().int().nonnegative(),
+    /** Total credits available right now (monthly_remaining + balance). */
+    total_available: z.number().int().nonnegative(),
+    /** ISO timestamp when the monthly window resets. */
+    resets_at: z.string().datetime(),
+});

package/dist/schemas/index.d.ts

@@ -8,6 +8,9 @@ export * from './skill-dependency.schema.js';
 export * from './skill-test.schema.js';
 export * from './marketplace.schema.js';
 export * from './billing.schema.js';
+export * from './credits.schema.js';
 export * from './install.schema.js';
 export * from './skill-pr.schema.js';
+export * from './intelligence.schema.js';
+export * from './api-keys.schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA"}

package/dist/schemas/index.js

@@ -8,5 +8,8 @@ export * from './skill-dependency.schema.js';
 export * from './skill-test.schema.js';
 export * from './marketplace.schema.js';
 export * from './billing.schema.js';
+export * from './credits.schema.js';
 export * from './install.schema.js';
 export * from './skill-pr.schema.js';
+export * from './intelligence.schema.js';
+export * from './api-keys.schema.js';

package/dist/schemas/intelligence.schema.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+export declare const agentTypeSchema: z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>;
+export declare const analyzeSkillInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    file_path: z.ZodString;
+    skill_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    agent_type: z.ZodDefault<z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    file_path: string;
+    agent_type: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp";
+    skill_id?: string | null | undefined;
+}, {
+    content: string;
+    file_path: string;
+    skill_id?: string | null | undefined;
+    agent_type?: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp" | undefined;
+}>;
+export type AnalyzeSkillInput = z.infer<typeof analyzeSkillInputSchema>;
+export declare const intelligenceSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<["local", "marketplace", "both"]>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    scope: "local" | "marketplace" | "both";
+}, {
+    query: string;
+    scope?: "local" | "marketplace" | "both" | undefined;
+}>;
+export type IntelligenceSearchInput = z.infer<typeof intelligenceSearchInputSchema>;
+export declare const llmSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    context?: string | undefined;
+}, {
+    query: string;
+    context?: string | undefined;
+}>;
+export type LlmSearchInput = z.infer<typeof llmSearchInputSchema>;
+export declare const updateAgentSettingsSchema: z.ZodObject<{
+    enabled_agents: z.ZodOptional<z.ZodArray<z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>, "many">>;
+    skill_paths: z.ZodOptional<z.ZodRecord<z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>, z.ZodObject<{
+        mac: z.ZodOptional<z.ZodString>;
+        windows: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        mac?: string | undefined;
+        windows?: string | undefined;
+    }, {
+        mac?: string | undefined;
+        windows?: string | undefined;
+    }>>>;
+    detected_os: z.ZodOptional<z.ZodEnum<["mac", "windows", "linux"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled_agents?: ("claude" | "codex" | "cursor" | "gemini" | "cline" | "amp")[] | undefined;
+    skill_paths?: Partial<Record<"claude" | "codex" | "cursor" | "gemini" | "cline" | "amp", {
+        mac?: string | undefined;
+        windows?: string | undefined;
+    }>> | undefined;
+    detected_os?: "mac" | "windows" | "linux" | undefined;
+}, {
+    enabled_agents?: ("claude" | "codex" | "cursor" | "gemini" | "cline" | "amp")[] | undefined;
+    skill_paths?: Partial<Record<"claude" | "codex" | "cursor" | "gemini" | "cline" | "amp", {
+        mac?: string | undefined;
+        windows?: string | undefined;
+    }>> | undefined;
+    detected_os?: "mac" | "windows" | "linux" | undefined;
+}>;
+export type UpdateAgentSettingsInput = z.infer<typeof updateAgentSettingsSchema>;
+export declare const recordSkillUsageSchema: z.ZodObject<{
+    skill_metadata_id: z.ZodString;
+    trigger_phrase: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    skill_metadata_id: string;
+    trigger_phrase?: string | null | undefined;
+}, {
+    skill_metadata_id: string;
+    trigger_phrase?: string | null | undefined;
+}>;
+export type RecordSkillUsageInput = z.infer<typeof recordSkillUsageSchema>;
+//# sourceMappingURL=intelligence.schema.d.ts.map

package/dist/schemas/intelligence.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/intelligence.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,eAAe,oEAAsB,CAAA;AAElD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,oBAAoB;;;;;;;;;EAG/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYpC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEhF,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/schemas/intelligence.schema.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { AGENT_TYPES } from '../types/intelligence.js';
+export const agentTypeSchema = z.enum(AGENT_TYPES);
+export const analyzeSkillInputSchema = z.object({
+    content: z.string().min(1).max(500_000),
+    file_path: z.string().min(1).max(2048),
+    skill_id: z.string().uuid().nullish(),
+    agent_type: agentTypeSchema.default('claude'),
+});
+export const intelligenceSearchInputSchema = z.object({
+    query: z.string().min(1).max(200),
+    scope: z.enum(['local', 'marketplace', 'both']).default('both'),
+});
+export const llmSearchInputSchema = z.object({
+    query: z.string().min(1).max(500),
+    context: z.string().max(2000).optional(),
+});
+export const updateAgentSettingsSchema = z.object({
+    enabled_agents: z.array(agentTypeSchema).min(1).optional(),
+    skill_paths: z
+        .record(agentTypeSchema, z.object({
+        mac: z.string().min(1).max(512).optional(),
+        windows: z.string().min(1).max(512).optional(),
+    }))
+        .optional(),
+    detected_os: z.enum(['mac', 'windows', 'linux']).optional(),
+});
+export const recordSkillUsageSchema = z.object({
+    skill_metadata_id: z.string().uuid(),
+    trigger_phrase: z.string().max(500).nullish(),
+});

package/dist/schemas/skill-pr.schema.d.ts

@@ -104,6 +104,25 @@ export declare const createPullRequestInputSchema: z.ZodObject<{
     proposed_description?: string | null | undefined;
 }>;
 export type CreatePullRequestInput = z.infer<typeof createPullRequestInputSchema>;
+/**
+ * Author can push a new "commit" — a fresh proposed_content body — to an
+ * already-open PR. Same shape as create minus the title (title doesn't
+ * change once the PR is open).
+ */
+export declare const updatePullRequestInputSchema: z.ZodObject<{
+    summary: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    proposed_content: z.ZodString;
+    proposed_description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    proposed_content: string;
+    summary?: string | null | undefined;
+    proposed_description?: string | null | undefined;
+}, {
+    proposed_content: string;
+    summary?: string | null | undefined;
+    proposed_description?: string | null | undefined;
+}>;
+export type UpdatePullRequestInput = z.infer<typeof updatePullRequestInputSchema>;
 export declare const skillPrCommentSchema: z.ZodObject<{
     id: z.ZodString;
     pull_request_id: z.ZodString;
@@ -402,4 +421,124 @@ export declare const pullRequestPageSchema: z.ZodObject<{
     base_description: string | null;
 }>;
 export type PullRequestPage = z.infer<typeof pullRequestPageSchema>;
+/**
+ * Cross-skill PR listing — used by the authenticated `/me/pulls` view.
+ * Each row carries a slim skill slice so the UI can render the
+ * "Proposed change to <skill name>" line + deep-link back to the skill.
+ */
+export declare const myPullRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    skill_id: z.ZodString;
+    author_id: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodNullable<z.ZodString>;
+    proposed_content: z.ZodString;
+    proposed_description: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<["open", "merged", "closed"]>;
+    merged_by: z.ZodNullable<z.ZodString>;
+    merged_at: z.ZodNullable<z.ZodString>;
+    closed_by: z.ZodNullable<z.ZodString>;
+    closed_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    /** Attached by the API: public-safe author slice for cards/avatars. */
+    author: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodNullable<z.ZodString>;
+        display_name: z.ZodNullable<z.ZodString>;
+        avatar_url: z.ZodNullable<z.ZodString>;
+        is_creator: z.ZodBoolean;
+        is_partner: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        username: string | null;
+        display_name: string | null;
+        avatar_url: string | null;
+        is_creator: boolean;
+        is_partner: boolean;
+    }, {
+        id: string;
+        username: string | null;
+        display_name: string | null;
+        avatar_url: string | null;
+        is_creator: boolean;
+        is_partner: boolean;
+    }>>>;
+} & {
+    skill: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        visibility: z.ZodEnum<["public", "private"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        slug: string;
+        visibility: "public" | "private";
+    }, {
+        id: string;
+        name: string;
+        slug: string;
+        visibility: "public" | "private";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "merged" | "closed";
+    id: string;
+    created_at: string;
+    updated_at: string;
+    skill_id: string;
+    summary: string | null;
+    skill: {
+        id: string;
+        name: string;
+        slug: string;
+        visibility: "public" | "private";
+    };
+    author_id: string;
+    title: string;
+    proposed_content: string;
+    proposed_description: string | null;
+    merged_by: string | null;
+    merged_at: string | null;
+    closed_by: string | null;
+    closed_at: string | null;
+    author?: {
+        id: string;
+        username: string | null;
+        display_name: string | null;
+        avatar_url: string | null;
+        is_creator: boolean;
+        is_partner: boolean;
+    } | null | undefined;
+}, {
+    status: "open" | "merged" | "closed";
+    id: string;
+    created_at: string;
+    updated_at: string;
+    skill_id: string;
+    summary: string | null;
+    skill: {
+        id: string;
+        name: string;
+        slug: string;
+        visibility: "public" | "private";
+    };
+    author_id: string;
+    title: string;
+    proposed_content: string;
+    proposed_description: string | null;
+    merged_by: string | null;
+    merged_at: string | null;
+    closed_by: string | null;
+    closed_at: string | null;
+    author?: {
+        id: string;
+        username: string | null;
+        display_name: string | null;
+        avatar_url: string | null;
+        is_creator: boolean;
+        is_partner: boolean;
+    } | null | undefined;
+}>;
+export type MyPullRequest = z.infer<typeof myPullRequestSchema>;
 //# sourceMappingURL=skill-pr.schema.d.ts.map

package/dist/schemas/skill-pr.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skill-pr.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-pr.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc,yCAAuC,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE9D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;IAejC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvE,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EAKvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;QAhDhC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmDvE,oFAAoF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpF,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"skill-pr.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-pr.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc,yCAAuC,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE9D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;IAejC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvE,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EAKvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAIvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;QA5DhC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+DvE,oFAAoF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpF,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;IA1E9B,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiFvE,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schemas/skill-pr.schema.js

@@ -34,6 +34,16 @@ export const createPullRequestInputSchema = z.object({
     proposed_content: z.string().min(1),
     proposed_description: z.string().max(500).optional().nullable(),
 });
+/**
+ * Author can push a new "commit" — a fresh proposed_content body — to an
+ * already-open PR. Same shape as create minus the title (title doesn't
+ * change once the PR is open).
+ */
+export const updatePullRequestInputSchema = z.object({
+    summary: z.string().max(2000).optional().nullable(),
+    proposed_content: z.string().min(1),
+    proposed_description: z.string().max(500).optional().nullable(),
+});
 export const skillPrCommentSchema = z.object({
     id: z.string().uuid(),
     pull_request_id: z.string().uuid(),
@@ -62,3 +72,16 @@ export const pullRequestPageSchema = z.object({
     base_content: z.string(),
     base_description: z.string().nullable(),
 });
+/**
+ * Cross-skill PR listing — used by the authenticated `/me/pulls` view.
+ * Each row carries a slim skill slice so the UI can render the
+ * "Proposed change to <skill name>" line + deep-link back to the skill.
+ */
+export const myPullRequestSchema = skillPullRequestSchema.extend({
+    skill: z.object({
+        id: z.string().uuid(),
+        slug: z.string(),
+        name: z.string(),
+        visibility: z.enum(['public', 'private']),
+    }),
+});

package/dist/schemas/skill-test.schema.d.ts

@@ -1,25 +1,20 @@
 import { z } from 'zod';
 /**
- * BYOK (Bring Your Own Key) tester input. The API **never** persists
- * the caller's Anthropic key — it's used once for the round-trip and
- * dropped. Store hashes of keys only if rate-limiting is added later.
+ * Managed Skill-Tester input. Prave provides the Anthropic API key
+ * server-side and meters usage in credits — one credit per request.
+ * Model is fixed to Haiku 4.5 for predictable cost; advanced users can
+ * later override via a per-plan whitelist.
  */
 export declare const skillTestInputSchema: z.ZodObject<{
     prompt: z.ZodString;
-    api_key: z.ZodString;
-    model: z.ZodOptional<z.ZodString>;
     max_tokens: z.ZodOptional<z.ZodNumber>;
     temperature: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
-    api_key: string;
-    model?: string | undefined;
     max_tokens?: number | undefined;
     temperature?: number | undefined;
 }, {
     prompt: string;
-    api_key: string;
-    model?: string | undefined;
     max_tokens?: number | undefined;
     temperature?: number | undefined;
 }>;

package/dist/schemas/skill-test.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skill-test.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-test.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAU/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"skill-test.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-test.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/schemas/skill-test.schema.js

@@ -1,17 +1,12 @@
 import { z } from 'zod';
 /**
- * BYOK (Bring Your Own Key) tester input. The API **never** persists
- * the caller's Anthropic key — it's used once for the round-trip and
- * dropped. Store hashes of keys only if rate-limiting is added later.
+ * Managed Skill-Tester input. Prave provides the Anthropic API key
+ * server-side and meters usage in credits — one credit per request.
+ * Model is fixed to Haiku 4.5 for predictable cost; advanced users can
+ * later override via a per-plan whitelist.
  */
 export const skillTestInputSchema = z.object({
     prompt: z.string().min(1).max(12_000),
-    api_key: z
-        .string()
-        .min(10)
-        .max(256)
-        .regex(/^sk-ant-/, 'Must be an Anthropic key (starts with sk-ant-)'),
-    model: z.string().min(1).max(80).optional(),
     max_tokens: z.number().int().min(1).max(8192).optional(),
     temperature: z.number().min(0).max(1).optional(),
 });

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './categories.js';
 export * from './plan-limits.js';
+export * from './intelligence.js';
 export type UserPlan = 'free' | 'explorer' | 'creator';
 export type UserRole = 'user' | 'admin';
 export interface Profile {

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAEhC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAA;AACtD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvC,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,OAAO,4BAA4B,EAAE,KAAK,EAAE,CAAA;IACpD,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;CACd"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AAEjC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAA;AACtD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvC,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,OAAO,4BAA4B,EAAE,KAAK,EAAE,CAAA;IACpD,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;CACd"}

package/dist/types/index.js

@@ -1,2 +1,3 @@
 export * from './categories.js';
 export * from './plan-limits.js';
+export * from './intelligence.js';

package/dist/types/intelligence.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Skill Intelligence — types shared across the API, web, CLI.
+ *
+ * Source-of-truth for the rows in `skill_metadata`, `skill_conflicts`,
+ * `skill_usage_stats`, and `user_agent_settings`. Every layer reads these.
+ */
+export declare const AGENT_TYPES: readonly ["claude", "codex", "cursor", "gemini", "cline", "amp"];
+export type AgentType = (typeof AGENT_TYPES)[number];
+export interface AgentMeta {
+    id: AgentType;
+    label: string;
+    description: string;
+    /** Default OS-specific skill paths used as a fallback in the UI. */
+    defaultPath: {
+        mac: string;
+        windows: string;
+    };
+    /** When true, the SKILL.md needs format conversion before deploy. */
+    conversionRequired: boolean;
+}
+export declare const AGENT_REGISTRY: Record<AgentType, AgentMeta>;
+export interface SkillMetadata {
+    id: string;
+    skill_id: string | null;
+    user_id: string;
+    name: string | null;
+    description: string | null;
+    triggers: string[];
+    slash_command: string | null;
+    disable_model_invocation: boolean;
+    user_invocable: boolean;
+    requires: string[];
+    estimated_tokens: number;
+    file_path: string;
+    agent_type: AgentType;
+    last_analyzed: string;
+    created_at: string;
+    updated_at: string;
+}
+export type ConflictType = 'trigger_overlap' | 'auto_invocation_collision' | 'dependency_conflict';
+export interface SkillConflict {
+    id: string;
+    user_id: string;
+    skill_a_id: string;
+    skill_b_id: string;
+    conflict_type: ConflictType;
+    conflict_detail: string | null;
+    detected_at: string;
+    skill_a_name?: string | null;
+    skill_b_name?: string | null;
+}
+export interface SkillUsageStat {
+    id: string;
+    user_id: string;
+    skill_metadata_id: string;
+    trigger_phrase: string | null;
+    triggered_at: string;
+}
+export interface UserAgentSettings {
+    user_id: string;
+    enabled_agents: AgentType[];
+    skill_paths: Record<AgentType, {
+        mac: string;
+        windows: string;
+    }>;
+    detected_os: 'mac' | 'windows' | 'linux' | null;
+    updated_at: string;
+}
+export interface IntelligenceOverview {
+    total_skills: number;
+    auto_trigger_count: number;
+    user_invocable_count: number;
+    total_estimated_tokens: number;
+    conflict_count: number;
+    agents: {
+        agent: AgentType;
+        skill_count: number;
+    }[];
+    /** Top 5 token-heaviest skills, for the panel summary. */
+    heaviest: Array<Pick<SkillMetadata, 'id' | 'name' | 'slash_command' | 'estimated_tokens'>>;
+}
+export interface IntelligenceOptimization {
+    underused: SkillMetadata[];
+    merge_candidates: Array<{
+        a: SkillMetadata;
+        b: SkillMetadata;
+        reason: string;
+    }>;
+    heavy: SkillMetadata[];
+    total_savings_estimate_tokens: number;
+}
+export interface IntelligenceSearchResult {
+    source: 'local' | 'marketplace';
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    slash_command: string | null;
+    estimated_tokens: number;
+    install_count?: number | null;
+    rating?: number | null;
+    is_installed: boolean;
+}
+export interface LlmSearchResult {
+    task: string;
+    keywords: string[];
+    scope: 'local' | 'marketplace' | 'both';
+    suggested_triggers: string[];
+    results: IntelligenceSearchResult[];
+}
+/** Shape returned to `prave whatdoes` and the Intelligence detail panel. */
+export interface SkillWhatDoes {
+    found: boolean;
+    source: 'local' | 'marketplace' | null;
+    metadata: SkillMetadata | null;
+    marketplace?: {
+        slug: string;
+        name: string;
+        description: string | null;
+        install_count: number;
+        rating: number | null;
+    } | null;
+    conflicts: SkillConflict[];
+    similar?: Array<{
+        slug: string;
+        name: string;
+    }>;
+}
+/** Token-tier classification used by the CLI + UI badges. */
+export type TokenTier = 'lean' | 'medium' | 'heavy';
+export declare const tokenTier: (n: number) => TokenTier;
+//# sourceMappingURL=intelligence.d.ts.map

package/dist/types/intelligence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.d.ts","sourceRoot":"","sources":["../../src/types/intelligence.ts"],"names":[],"mappings":"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"}

package/dist/types/intelligence.js

@@ -0,0 +1,52 @@
+/**
+ * Skill Intelligence — types shared across the API, web, CLI.
+ *
+ * Source-of-truth for the rows in `skill_metadata`, `skill_conflicts`,
+ * `skill_usage_stats`, and `user_agent_settings`. Every layer reads these.
+ */
+export const AGENT_TYPES = ['claude', 'codex', 'cursor', 'gemini', 'cline', 'amp'];
+export const AGENT_REGISTRY = {
+    claude: {
+        id: 'claude',
+        label: 'Claude Code',
+        description: "Anthropic's terminal-based coding agent",
+        defaultPath: { mac: '~/.claude/skills/', windows: '%APPDATA%\\Claude\\skills\\' },
+        conversionRequired: false,
+    },
+    codex: {
+        id: 'codex',
+        label: 'OpenAI Codex',
+        description: "OpenAI's CLI coding agent",
+        defaultPath: { mac: '~/.codex/skills/', windows: '%APPDATA%\\Codex\\skills\\' },
+        conversionRequired: false,
+    },
+    cursor: {
+        id: 'cursor',
+        label: 'Cursor',
+        description: 'AI-first code editor',
+        defaultPath: { mac: '.cursor/rules/', windows: '.cursor\\rules\\' },
+        conversionRequired: true,
+    },
+    gemini: {
+        id: 'gemini',
+        label: 'Gemini CLI',
+        description: "Google's terminal agent",
+        defaultPath: { mac: '~/.gemini/skills/', windows: '%APPDATA%\\Gemini\\skills\\' },
+        conversionRequired: false,
+    },
+    cline: {
+        id: 'cline',
+        label: 'Cline',
+        description: 'Open-source VS Code agent',
+        defaultPath: { mac: '~/.cline/skills/', windows: '%APPDATA%\\Cline\\skills\\' },
+        conversionRequired: false,
+    },
+    amp: {
+        id: 'amp',
+        label: 'Amp',
+        description: 'Ampcode terminal agent',
+        defaultPath: { mac: '~/.amp/skills/', windows: '%APPDATA%\\Amp\\skills\\' },
+        conversionRequired: false,
+    },
+};
+export const tokenTier = (n) => n < 500 ? 'lean' : n < 2000 ? 'medium' : 'heavy';

package/dist/types/plan-limits.js

@@ -9,7 +9,7 @@ export const PLAN_LIMITS = {
         max_private_skills: 0,
         can_versioning: false,
         max_marketplace_listings: 0,
-        tester_credits_monthly: 0,
+        tester_credits_monthly: 10,
         max_bookmarks: 5,
         cli_max_imports: 10,
         cli_exports_monthly: 0,
@@ -24,14 +24,14 @@ export const PLAN_LIMITS = {
     explorer: {
         label: 'Explorer',
         price_eur_monthly: 4,
-        tagline: 'For developers building, sharing and selling Skills.',
-        creator_revenue_share: 0.7,
+        tagline: 'For developers building and shipping Skills.',
+        creator_revenue_share: null,
         max_public_skills: 20,
         can_private_skills: true,
         max_private_skills: 20,
         can_versioning: true,
-        max_marketplace_listings: 5,
-        tester_credits_monthly: 30,
+        max_marketplace_listings: 0,
+        tester_credits_monthly: 80,
         max_bookmarks: null,
         cli_max_imports: null,
         cli_exports_monthly: 50,
@@ -53,7 +53,7 @@ export const PLAN_LIMITS = {
         max_private_skills: null,
         can_versioning: true,
         max_marketplace_listings: null,
-        tester_credits_monthly: 150,
+        tester_credits_monthly: 250,
         max_bookmarks: null,
         cli_max_imports: null,
         cli_exports_monthly: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prave/shared",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/schemas/org.schema.d.ts

@@ -1,112 +0,0 @@
-import { z } from 'zod';
-export declare const orgRoleSchema: z.ZodEnum<["owner", "admin", "member"]>;
-export type OrgRole = z.infer<typeof orgRoleSchema>;
-export declare const orgSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    slug: z.ZodString;
-    owner_id: z.ZodString;
-    stripe_subscription_id: z.ZodNullable<z.ZodString>;
-    seats: z.ZodNumber;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    owner_id: string;
-    name: string;
-    slug: string;
-    created_at: string;
-    updated_at: string;
-    stripe_subscription_id: string | null;
-    seats: number;
-}, {
-    id: string;
-    owner_id: string;
-    name: string;
-    slug: string;
-    created_at: string;
-    updated_at: string;
-    stripe_subscription_id: string | null;
-    seats: number;
-}>;
-export type Org = z.infer<typeof orgSchema>;
-export declare const orgMemberSchema: z.ZodObject<{
-    org_id: z.ZodString;
-    user_id: z.ZodString;
-    role: z.ZodEnum<["owner", "admin", "member"]>;
-    invited_email: z.ZodNullable<z.ZodString>;
-    joined_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    user_id: string;
-    org_id: string;
-    role: "owner" | "admin" | "member";
-    invited_email: string | null;
-    joined_at: string;
-}, {
-    user_id: string;
-    org_id: string;
-    role: "owner" | "admin" | "member";
-    invited_email: string | null;
-    joined_at: string;
-}>;
-export type OrgMember = z.infer<typeof orgMemberSchema>;
-/** Hydrated row used by the Teams panel — joins the auth user's email/name. */
-export declare const orgMemberRowSchema: z.ZodObject<{
-    org_id: z.ZodString;
-    user_id: z.ZodString;
-    role: z.ZodEnum<["owner", "admin", "member"]>;
-    invited_email: z.ZodNullable<z.ZodString>;
-    joined_at: z.ZodString;
-} & {
-    email: z.ZodNullable<z.ZodString>;
-    display_name: z.ZodNullable<z.ZodString>;
-    avatar_url: z.ZodNullable<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    display_name: string | null;
-    avatar_url: string | null;
-    user_id: string;
-    email: string | null;
-    org_id: string;
-    role: "owner" | "admin" | "member";
-    invited_email: string | null;
-    joined_at: string;
-}, {
-    display_name: string | null;
-    avatar_url: string | null;
-    user_id: string;
-    email: string | null;
-    org_id: string;
-    role: "owner" | "admin" | "member";
-    invited_email: string | null;
-    joined_at: string;
-}>;
-export type OrgMemberRow = z.infer<typeof orgMemberRowSchema>;
-export declare const createOrgInputSchema: z.ZodObject<Pick<{
-    id: z.ZodString;
-    name: z.ZodString;
-    slug: z.ZodString;
-    owner_id: z.ZodString;
-    stripe_subscription_id: z.ZodNullable<z.ZodString>;
-    seats: z.ZodNumber;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, "name" | "slug">, "strip", z.ZodTypeAny, {
-    name: string;
-    slug: string;
-}, {
-    name: string;
-    slug: string;
-}>;
-export type CreateOrgInput = z.infer<typeof createOrgInputSchema>;
-export declare const addMemberInputSchema: z.ZodObject<{
-    email: z.ZodString;
-    role: z.ZodDefault<z.ZodEnum<["admin", "member"]>>;
-}, "strip", z.ZodTypeAny, {
-    email: string;
-    role: "admin" | "member";
-}, {
-    email: string;
-    role?: "admin" | "member" | undefined;
-}>;
-export type AddMemberInput = z.infer<typeof addMemberInputSchema>;
-//# sourceMappingURL=org.schema.d.ts.map

package/dist/schemas/org.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"org.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/org.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,aAAa,yCAAuC,CAAA;AACjE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;EAapB,CAAA;AACF,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAM1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAA6C,CAAA;AAC9E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,oBAAoB;;;;;;;;;EAG/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/schemas/org.schema.js

@@ -1,34 +0,0 @@
-import { z } from 'zod';
-export const orgRoleSchema = z.enum(['owner', 'admin', 'member']);
-export const orgSchema = z.object({
-    id: z.string().uuid(),
-    name: z.string().min(1).max(120),
-    slug: z
-        .string()
-        .min(1)
-        .max(80)
-        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'slug must be kebab-case'),
-    owner_id: z.string().uuid(),
-    stripe_subscription_id: z.string().nullable(),
-    seats: z.number().int().positive(),
-    created_at: z.string().datetime(),
-    updated_at: z.string().datetime(),
-});
-export const orgMemberSchema = z.object({
-    org_id: z.string().uuid(),
-    user_id: z.string().uuid(),
-    role: orgRoleSchema,
-    invited_email: z.string().email().nullable(),
-    joined_at: z.string().datetime(),
-});
-/** Hydrated row used by the Teams panel — joins the auth user's email/name. */
-export const orgMemberRowSchema = orgMemberSchema.extend({
-    email: z.string().email().nullable(),
-    display_name: z.string().nullable(),
-    avatar_url: z.string().nullable(),
-});
-export const createOrgInputSchema = orgSchema.pick({ name: true, slug: true });
-export const addMemberInputSchema = z.object({
-    email: z.string().email(),
-    role: z.enum(['admin', 'member']).default('member'),
-});