cakranala 0.0.0-stage → 0.1.0

package/dist/collect/tiktok.d.ts

@@ -0,0 +1,28 @@
+import { type Dataset } from "../engine";
+export interface SidecarConfig {
+    baseUrl: string;
+    username: string;
+    password: string;
+}
+export declare function sidecarFromEnv(env?: Record<string, string | undefined>): SidecarConfig | undefined;
+export declare function tiktokAccount(cookie: string, userAgent?: string): Promise<{
+    id: string;
+    handle: string;
+    name: string;
+}>;
+export declare function createTiktokCollector(config: SidecarConfig): {
+    check(cookies: string, userAgent?: string): Promise<{
+        authenticated: boolean;
+        browser: string;
+    }>;
+    importIdentity(cookies: string, userAgent?: string): Promise<string>;
+    search(keyword: string, o?: {
+        videos?: number;
+        pages?: number;
+        identity?: string;
+    }): Promise<Dataset>;
+    video(contentId: string, o?: {
+        pages?: number;
+        identity?: string;
+    }): Promise<Dataset>;
+};

package/dist/collect/x.d.ts

@@ -0,0 +1,37 @@
+import { type Actor, type Dataset } from "../engine";
+export interface XSession {
+    authToken: string;
+    ct0: string;
+    userAgent: string;
+    proxy?: string;
+}
+export interface Profile {
+    id: string;
+    handle: string;
+    name: string;
+    followers?: number;
+    createdAt?: number;
+}
+export interface SearchOptions {
+    pages?: number;
+    since?: string;
+    lang?: string;
+    delayMs?: [number, number];
+    onPage?: (info: {
+        page: number;
+        tweets: number;
+        remaining: number | null;
+    }) => void;
+}
+export interface XRateState {
+    remaining: number | null;
+    reset: number | null;
+}
+export declare function createXCollector(session: XSession): Promise<{
+    rate: XRateState;
+    search(query: string, o?: SearchOptions): Promise<Dataset>;
+    me(): Promise<Profile>;
+    retweeters(id: string, pages?: number): Promise<Actor[]>;
+    conversation(id: string, o?: Pick<SearchOptions, "pages" | "delayMs">): Promise<Dataset>;
+}>;
+export declare function sessionFromEnv(env?: Record<string, string | undefined>): XSession | undefined;

package/dist/collect/youtube.d.ts

@@ -0,0 +1,14 @@
+import { type Dataset } from "../engine";
+export interface YoutubeOptions {
+    videos?: number;
+    pages?: number;
+}
+export declare function createYoutubeCollector(cookie?: string, proxy?: string): Promise<{
+    me(): Promise<{
+        id: string;
+        handle: any;
+        name: any;
+    }>;
+    search(query: string, o?: YoutubeOptions): Promise<Dataset>;
+    video(id: string, o?: YoutubeOptions): Promise<Dataset>;
+}>;

package/dist/embed/embed.d.ts

@@ -0,0 +1,13 @@
+import type { Embedder } from "../engine";
+export declare const MODEL = "Xenova/multilingual-e5-small";
+export interface E5Options {
+    model?: string;
+    dtype?: "fp32" | "fp16" | "q8" | "q4";
+    batch?: number;
+    progress?: (file: string, loaded: number, total: number) => void;
+}
+type Transformers = typeof import("@huggingface/transformers");
+export declare function transformers(): Promise<Transformers | undefined>;
+export declare const modelCached: (model?: string) => boolean;
+export declare function createE5Embedder(opts?: E5Options): Promise<Embedder>;
+export {};

package/dist/embed/index.d.ts

@@ -0,0 +1,2 @@
+export { createE5Embedder, modelCached, transformers, MODEL, type E5Options } from "./embed";
+export { createReasoner, reasonerFromEnv, type OpenAIReasonerOptions } from "./reason";

package/dist/embed/index.js

@@ -0,0 +1,2 @@
+// @bun
+import{existsSync as h}from"fs";import{createRequire as _}from"module";import{join as s}from"path";import{pathToFileURL as O}from"url";import{homedir as L}from"os";import{join as g,resolve as y}from"path";var D=()=>y(process.env.CAKRANALA_DATA??".cakranala"),m=()=>y(process.env.CAKRANALA_CACHE??g(process.env.XDG_CACHE_HOME??g(L(),".cache"),"cakranala"));var l="Xenova/multilingual-e5-small";async function E(){let e=await import("@huggingface/transformers").catch(()=>{return});if(e)return e;let r=s(m(),"deps");if(!h(s(r,"node_modules","@huggingface","transformers")))return;return import(O(_(s(r,"package.json")).resolve("@huggingface/transformers")).href)}var R=(e=l)=>h(s(m(),"models",e));async function M(e={}){let r=await E();if(!r)throw Error("layer semantik butuh @huggingface/transformers, jalankan: cakranala install");r.env.cacheDir=s(m(),"models");let o=r.pipeline,c=e.progress&&((t)=>t.status==="progress"&&e.progress(t.file??"",t.loaded??0,t.total??0)),n=await o("feature-extraction",e.model??l,{dtype:e.dtype??"q8",progress_callback:c}),p=e.batch??64;return{async embed(t){let d=[];for(let i=0;i<t.length;i+=p){let u=await n(t.slice(i,i+p).map((a)=>`query: ${a}`),{pooling:"mean",normalize:!0}),[A,f]=u.dims,x=u.data;for(let a=0;a<A;a++)d.push(x.slice(a*f,(a+1)*f))}return d}}}function b(e){return{async complete(r,o={}){let c=o.images?.length?[{type:"text",text:r},...o.images.map((t)=>({type:"image_url",image_url:{url:t}}))]:r,n=await fetch(`${e.baseUrl.replace(/\/$/,"")}/chat/completions`,{method:"POST",headers:{...e.apiKey?{Authorization:`Bearer ${e.apiKey}`}:{},"Content-Type":"application/json"},signal:AbortSignal.timeout(e.timeoutMs??120000),body:JSON.stringify({model:e.model,temperature:e.temperature??0.7,messages:[...o.system?[{role:"system",content:o.system}]:[],{role:"user",content:c}],...o.json?{response_format:{type:"json_object"}}:{}})});if(!n.ok)throw Error(`reasoner ${n.status}: ${(await n.text()).slice(0,200)}`);return(await n.json()).choices[0].message.content}}}function w(e=process.env){if(!e.LLM_BASE_URL||!e.LLM_MODEL)return;return b({baseUrl:e.LLM_BASE_URL,apiKey:e.LLM_API_KEY,model:e.LLM_MODEL})}export{l as MODEL,M as createE5Embedder,b as createReasoner,R as modelCached,w as reasonerFromEnv,E as transformers};

package/dist/embed/reason.d.ts

@@ -0,0 +1,10 @@
+import type { Reasoner } from "../engine";
+export interface OpenAIReasonerOptions {
+    baseUrl: string;
+    apiKey?: string;
+    model: string;
+    temperature?: number;
+    timeoutMs?: number;
+}
+export declare function createReasoner(o: OpenAIReasonerOptions): Reasoner;
+export declare function reasonerFromEnv(env?: Record<string, string | undefined>): Reasoner | undefined;

package/dist/engine/detect/consensus.d.ts

@@ -0,0 +1,40 @@
+import type { Event } from "../schema";
+import type { Cluster } from "./graph";
+export interface Sie {
+    value: number;
+    ci: [number, number];
+}
+export interface Narrative {
+    id: string;
+    sample: string;
+    tags: string[];
+    supporters: number;
+    events: number;
+    sie: Sie;
+    iks: number;
+    coordinated: number;
+    verdict: "manufactured" | "organic";
+    p: number;
+    clusters: {
+        id: string;
+        actors: number;
+        p: number;
+    }[];
+    counterfactual: {
+        binSec: number;
+        start: number;
+        all: number[];
+        organic: number[];
+    };
+}
+export declare function sie(supporters: string[], membership: Map<string, Cluster>): number;
+export interface HeldOut {
+    clusterOf: (e: Event) => Cluster | undefined;
+    baseRate: number;
+}
+export declare function narratives(events: Event[], clusters: Cluster[], frames: Map<number, number> | undefined, opts: {
+    minSupporters: number;
+    seed: number;
+    alpha: number;
+    syncSec: number;
+}, heldOut?: HeldOut): Narrative[];

package/dist/engine/detect/forensics.d.ts

@@ -0,0 +1,20 @@
+import type { Event } from "../schema";
+export interface Forensics {
+    onset: {
+        ts: number;
+        actors: number;
+        windowSec: number;
+    };
+    waves: number;
+    seeders: {
+        actor: string;
+        leadScore: number;
+    }[];
+    rotation: number | null;
+    cadence: {
+        medianSec: number;
+        cv: number;
+    } | null;
+    talkingPoints: string[];
+}
+export declare function forensics(members: string[], all: Event[], gapSec?: number): Forensics;

package/dist/engine/detect/graph.d.ts

@@ -0,0 +1,44 @@
+import type { LayerId, LayerResult, PairStat } from "./layers";
+export interface Edge {
+    a: string;
+    b: string;
+    rho: number;
+    p: number;
+    layers: Partial<Record<LayerId, PairStat>>;
+}
+export interface LayerEvidence {
+    layer: LayerId;
+    pairs: number;
+    meanEpisodes: number;
+    meanObserved: number;
+    meanExpected: number;
+}
+export interface Cluster {
+    id: string;
+    members: string[];
+    rho: number;
+    p: number;
+    score: number;
+    families: {
+        layers: LayerId[];
+        strength: number;
+    }[];
+    layers: LayerEvidence[];
+}
+export interface Fusion {
+    families: LayerId[][];
+    minFamilies: number;
+    edgeAlphas: number[];
+    fdr: number;
+}
+export declare function detect(results: LayerResult[], o: Fusion & {
+    minClusterSize: number;
+    minDegree: number;
+    seed: number;
+}): {
+    real: Map<string, number>;
+    edges: Edge[];
+    clusters: Cluster[];
+    alpha: number;
+    decoyFdr: number;
+};

package/dist/engine/detect/index.d.ts

@@ -0,0 +1,52 @@
+import type { Dataset } from "../schema";
+import type { Embedder, Reasoner } from "../ports";
+import { type LayerId, type LayerOptions } from "./layers";
+import { type Cluster, type Edge } from "./graph";
+import { type Forensics } from "./forensics";
+import { type Narrative } from "./consensus";
+export interface AnalyzeOptions extends LayerOptions {
+    layers: LayerId[];
+    families: LayerId[][];
+    minFamilies: number;
+    edgeAlphas: number[];
+    fdr: number;
+    clusterAlpha: number;
+    minClusterSize: number;
+    minDegree: number;
+    minClusterRho: number;
+    minSupporters: number;
+    verdictAlpha: number;
+    syncSec: number;
+    verdictFolds: 1 | 2;
+    embedder?: Embedder;
+    reasoner?: Reasoner;
+}
+export interface ClusterReport extends Cluster {
+    forensics: Forensics;
+    brief?: string;
+}
+export interface Report {
+    generatedAt: number;
+    stats: {
+        actors: number;
+        events: number;
+        flaggedActors: number;
+        layersRun: LayerId[];
+    };
+    tests: Partial<Record<LayerId, {
+        candidates: number;
+        nominal: number;
+        dispersion: number;
+    }>>;
+    null: {
+        replicates: number;
+        alpha: number;
+        decoyFdr: number;
+    };
+    edges: Edge[];
+    clusters: ClusterReport[];
+    narratives: Narrative[];
+    scores: Record<string, number>;
+}
+export declare const DEFAULTS: AnalyzeOptions;
+export declare function analyze(ds: Dataset, options?: Partial<AnalyzeOptions>): Promise<Report>;

package/dist/engine/detect/layers.d.ts

@@ -0,0 +1,32 @@
+import type { Dataset } from "../schema";
+export type LayerId = "coaction" | "coframing" | "rhythm" | "copypasta" | "lifecycle";
+export declare const LAYERS: LayerId[];
+export interface LayerOptions {
+    windowSec: Partial<Record<LayerId, number>>;
+    similarityQuantile: number;
+    copypastaFloor: number;
+    minEpisodes: number;
+    maxGroup: number;
+    groupQuantile: number;
+    nullReplicates: number;
+    shiftMax: number;
+    strataWindows: number;
+    seed: number;
+}
+export declare const LAYER_DEFAULTS: LayerOptions;
+export interface PairStat {
+    w: number;
+    observed: number;
+    expected: number;
+    p: number;
+    episodes: number;
+}
+export interface LayerResult {
+    id: LayerId;
+    candidates: number;
+    dispersion: number;
+    pairs: Map<string, PairStat>;
+    replicates: Map<string, number>[];
+}
+export declare const handleShape: (handle?: string) => string;
+export declare function runLayers(ds: Dataset, opts: LayerOptions, enabled: LayerId[], frames?: Map<number, number>): LayerResult[];

package/dist/engine/evaluate.d.ts

@@ -0,0 +1,23 @@
+import type { Truth } from "./schema";
+import type { Report } from "./detect";
+export interface Evaluation {
+    precision: number;
+    recall: number;
+    f1: number;
+    operations: {
+        id: string;
+        kind: string;
+        size: number;
+        recall: number;
+    }[];
+    organicFlagRate: number;
+    viralFlagRate: number | null;
+}
+export declare function evaluate(report: Report, truth: Truth): Evaluation;
+export interface Ranking {
+    ap: number;
+    prevalence: number;
+    lift: number;
+    precisionAt: Record<string, number>;
+}
+export declare function ranking(scores: Record<string, number>, truth: Truth, ks?: number[]): Ranking;

package/dist/engine/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./schema";
+export type { Embedder, Reasoner } from "./ports";
+export { analyze, DEFAULTS, type AnalyzeOptions, type Report, type ClusterReport } from "./detect";
+export { LAYERS, type LayerId } from "./detect/layers";
+export type { Edge, Cluster } from "./detect/graph";
+export type { Narrative, Sie } from "./detect/consensus";
+export type { Forensics } from "./detect/forensics";
+export { simulate, generateScenario, enrichScenario, type Scenario, type OperationKind } from "./simulate";
+export { evaluate, ranking, type Evaluation, type Ranking } from "./evaluate";
+export { shield, type ShieldInput, type ShieldContext, type ShieldResult, type UrlFinding, type Match } from "./shield";
+export { pseudonymize } from "./privacy";
+export { normalize, plain } from "./text";
+export { uuidFrom } from "./util";

package/dist/engine/ports.d.ts

@@ -0,0 +1,10 @@
+export interface Embedder {
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+export interface Reasoner {
+    complete(prompt: string, opts?: {
+        system?: string;
+        json?: boolean;
+        images?: string[];
+    }): Promise<string>;
+}

package/dist/engine/privacy.d.ts

@@ -0,0 +1,2 @@
+import type { Dataset } from "./schema";
+export declare function pseudonymize(ds: Dataset, secret: string): Promise<Dataset>;

package/dist/engine/schema.d.ts

@@ -0,0 +1,40 @@
+export declare const SCHEMA_VERSION = 1;
+export type Action = "post" | "reply" | "quote" | "reshare" | "comment" | "react";
+export type TimePrecision = "ms" | "s" | "min" | "approx";
+export interface Actor {
+    id: string;
+    platform: string;
+    handle?: string;
+    createdAt?: number;
+    followers?: number;
+    following?: number;
+    posts?: number;
+    reshared?: string[];
+    shape?: string;
+}
+export interface Event {
+    id: string;
+    actor: string;
+    action: Action;
+    ts: number;
+    precision?: TimePrecision;
+    target?: string;
+    text?: string;
+    tags?: string[];
+    urls?: string[];
+    lang?: string;
+}
+export type Truth = Record<string, string>;
+export interface Dataset {
+    version: typeof SCHEMA_VERSION;
+    actors: Actor[];
+    events: Event[];
+    truth?: Truth;
+    meta?: {
+        source?: string;
+        query?: string;
+        coverage?: number;
+        collectedAt?: number;
+    };
+}
+export declare function validate(input: unknown): Dataset;

package/dist/engine/shield.d.ts

@@ -0,0 +1,57 @@
+import type { Embedder, Reasoner } from "./ports";
+import type { Report } from "./detect";
+export interface ShieldInput {
+    text?: string;
+    image?: string;
+}
+export interface ShieldContext {
+    report?: Report;
+    officialDomains?: string[];
+    library?: {
+        claim: string;
+        verdict: string;
+        source?: string;
+        title?: string;
+    }[];
+    taxonomy?: {
+        id: string;
+        name: string;
+        description: string;
+    }[];
+    embedder?: Embedder;
+    reasoner?: Reasoner;
+}
+export interface UrlFinding {
+    url: string;
+    host: string;
+    flags: string[];
+    imitates?: string;
+}
+export interface Match {
+    kind: "narasi" | "klaster" | "pustaka";
+    ref: string;
+    similarity: number;
+    text: string;
+    supporters?: number;
+    sie?: number;
+    iks?: number;
+    verdict?: string;
+    title?: string;
+}
+export interface ShieldResult {
+    text: string;
+    risk: "rendah" | "sedang" | "tinggi";
+    score: number;
+    cues: string[];
+    urls: UrlFinding[];
+    techniques: {
+        id?: string;
+        name: string;
+        quote: string;
+        why: string;
+    }[];
+    matches: Match[];
+    summary?: string;
+    advice: string[];
+}
+export declare function shield(input: ShieldInput, ctx?: ShieldContext): Promise<ShieldResult>;

package/dist/engine/simulate.d.ts

@@ -0,0 +1,45 @@
+import { type Dataset } from "./schema";
+import type { Reasoner } from "./ports";
+export type OperationKind = "paid" | "botfarm" | "swarm";
+export interface Scenario {
+    name: string;
+    durationMin: number;
+    organic: {
+        actors: number;
+        hubs: number;
+        eventsPerActor: number;
+        narrativeShare: number;
+    };
+    topics: {
+        texts: string[];
+        tags?: string[];
+    }[];
+    narratives: {
+        id: string;
+        claims: string[];
+        organicTakes: string[];
+        tags: string[];
+        paraphrases?: string[];
+    }[];
+    viral?: {
+        atMin: number;
+        size: number;
+        texts: string[];
+        tags: string[];
+    };
+    operations: {
+        id: string;
+        kind: OperationKind;
+        size: number;
+        narrative: string;
+        waves: number;
+    }[];
+    fillers: {
+        openers: string[];
+        closers: string[];
+        emoji: string[];
+    };
+}
+export declare function simulate(scenario: Scenario, seed?: number): Dataset;
+export declare function generateScenario(reasoner: Reasoner, theme: string, base: Scenario): Promise<Scenario>;
+export declare function enrichScenario(reasoner: Reasoner, scenario: Scenario, count?: number): Promise<Scenario>;

package/dist/engine/text.d.ts

@@ -0,0 +1,9 @@
+export declare function normalize(text: string): string;
+export declare const tokens: (text: string) => string[];
+export declare function shingles(text: string, n?: number): Set<string>;
+export declare function jaccard(a: Set<string>, b: Set<string>): number;
+export declare function nearDuplicateGroups(texts: string[], threshold: number): number[];
+export declare function centered(vectors: Float32Array[]): Float32Array<ArrayBuffer>[];
+export declare function cosine(a: Float32Array, b: Float32Array): number;
+export declare function kmeans(vectors: Float32Array[], k: number, r: () => number, iterations?: number): number[];
+export declare const plain: (s: string) => string;

package/dist/engine/util.d.ts

@@ -0,0 +1,26 @@
+export type Rng = () => number;
+export declare function rng(seed: number): Rng;
+export declare const pick: <T>(r: Rng, xs: readonly T[]) => T;
+export declare function gauss(r: Rng, mean?: number, sd?: number): number;
+export declare const expo: (r: Rng, mean: number) => number;
+export declare function hash32(s: string, seed?: number): number;
+export declare const pairKey: (a: string, b: string) => string;
+export declare const splitPair: (k: string) => [string, string];
+export declare function quantile(xs: number[], q: number): number;
+export declare const mean: (xs: number[]) => number;
+export declare function groupBy<T, K>(xs: Iterable<T>, key: (x: T) => K): Map<K, T[]>;
+export declare class UnionFind {
+    private p;
+    constructor(n: number);
+    find(i: number): number;
+    union(a: number, b: number): void;
+}
+export declare function randomPairQuantile(n: number, sim: (i: number, j: number) => number, q: number, r: Rng, samples?: number): number;
+export declare function poissonTail(k: number, lambda: number): number;
+export declare function shuffle<T>(r: Rng, xs: T[]): T[];
+export declare function binomialTail(k: number, n: number, p: number): number;
+export declare function uuidFrom(input: string): string;
+export declare function lgamma(x: number): number;
+export declare function nbTail(k: number, mu: number, dispersion: number): number;
+export declare function cauchyCombine(ps: number[]): number;
+export declare function partialConjunction(ps: number[], u: number): number;

package/dist/home.d.ts

@@ -0,0 +1,2 @@
+export declare const dataDir: () => string;
+export declare const cacheDir: () => string;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./engine";