@koalaauto/agentchannel 0.0.0-stage → 3.0.0

package/dist/src/import.d.ts

@@ -0,0 +1,245 @@
+import type { Client } from './client.js';
+export interface ExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export type Exec = (cmd: string, args: string[]) => Promise<ExecResult>;
+/** Runs `gh` / `lark-cli` (ACH_GH_CLI / ACH_LARK_CLI override the binaries). */
+export declare function makeExec(env: NodeJS.ProcessEnv): Exec;
+export declare class ImportError extends Error {
+}
+export interface GhItem {
+    kind: 'github_issue' | 'github_pr';
+    repo: string;
+    number: number;
+    url: string;
+    state: string;
+    title: string;
+    author: string;
+    author_bot: boolean;
+    assignees: string[];
+    created_at: string;
+    updated_at: string;
+    /** when it was closed or merged ('' while open) */
+    closed_at: string;
+    labels: string[];
+    excerpt: string;
+}
+export interface RepoData {
+    full: string;
+    name: string;
+    description: string;
+    pushedAt: string;
+    commits: {
+        login: string;
+        name: string;
+        bot: boolean;
+    }[];
+    issues: GhItem[];
+    prs: GhItem[];
+}
+export interface Collected {
+    org: string;
+    since: string;
+    self: string;
+    repos: RepoData[];
+    users: Record<string, {
+        name: string;
+        email: string;
+        bot: boolean;
+    }>;
+}
+export interface PlanChannel {
+    name: string;
+    title?: string;
+    description?: string;
+    repos: string[];
+    visibility?: 'team' | 'private';
+    stats?: {
+        issues: number;
+        prs: number;
+        commits: number;
+    };
+}
+export interface PlanPerson {
+    github_login: string;
+    name: string;
+    email?: string;
+    is_admin?: boolean;
+    self?: boolean;
+    invite: boolean;
+    role?: string;
+    note?: string;
+    channels?: string[];
+    stats?: {
+        commits: number;
+        issues_opened: number;
+        prs_opened: number;
+        assigned: number;
+        commits_by_repo: Record<string, number>;
+    };
+    feishu_open_id?: string;
+}
+export interface Plan {
+    version: 1;
+    source: {
+        kind: 'github';
+        org: string;
+    };
+    since: string;
+    generated_at: string;
+    channels: PlanChannel[];
+    people: PlanPerson[];
+    bots: string[];
+    unlinked_commit_authors: string[];
+    counts: {
+        repos: number;
+        issues: number;
+        prs: number;
+        commits: number;
+    };
+}
+/** "60d", "8w", "3m" (months), or an ISO date -> ISO time. */
+export declare function parseSince(s: string | undefined, now?: number): string;
+/** Bots never become people: [bot] logins, GitHub type Bot, known agent names, *bot. */
+export declare function isBot(login: string, flagged?: boolean): boolean;
+export declare function excerptOf(body: string | undefined, max?: number): string;
+/** Items whose labels or title name one of these are never sent to the hub (case-insensitive substring). */
+export declare const DEFAULT_EXCLUDE: string[];
+/** Closed/merged items newer than this become posts by default; older ones only seed the wiki. */
+export declare const DEFAULT_CLOSED_DAYS = 7;
+/** Closed/merged items used to seed Memory (links only): the last N months by default, or all (--seed-all). */
+export declare const DEFAULT_SEED_MONTHS = 6;
+export interface Selection {
+    items: GhItem[];
+    archive: GhItem[];
+    tooOld: GhItem[];
+    excluded: GhItem[];
+    closedCutoff: string;
+    seedCutoff?: string;
+}
+export declare function isExcluded(i: Pick<GhItem, 'title' | 'labels'>, terms: string[]): boolean;
+/**
+ * What gets posted. Sensitive items (labels/title match `exclude`) are dropped
+ * entirely. Open items are posted; closed/merged ones only when they closed
+ * after `closedCutoff` ('' = all of them); older closed ones go to `archive`.
+ */
+export declare function selectItems(all: GhItem[], o: {
+    exclude: string[];
+    closedCutoff: string;
+    seedCutoff?: string;
+}): Selection;
+/** --exclude a,b / --no-exclude -> the exclusion terms. */
+export declare function excludeTerms(values: Record<string, unknown>): string[];
+/** --seed-all / --seed-months N -> the Memory seed cutoff ('' = everything). */
+export declare function seedCutoff(values: Record<string, unknown>, now: number): string;
+/** The two import ranges as the hub stores them (wizard-ready API fields). */
+export declare function importRanges(values: Record<string, unknown>): {
+    post_closed_days?: number;
+    seed_months?: number;
+    seed?: 'all';
+};
+/** --all / --closed-days N (alias --post-closed-days) -> the closed-item cutoff ('' = no cutoff). */
+export declare function closedCutoff(values: Record<string, unknown>, now: number): string;
+/** Issues and PRs of one repo updated since `since`. */
+export declare function fetchItems(exec: Exec, full: string, since: string, log?: (s: string) => void): Promise<{
+    issues: GhItem[];
+    prs: GhItem[];
+}>;
+export interface GhRelease {
+    repo: string;
+    tag: string;
+    name: string;
+    url: string;
+    published_at: string;
+}
+/** Releases of one repo published since `since` (read-only; drafts skipped). Missing access -> none. */
+export declare function fetchReleases(exec: Exec, full: string, since: string): Promise<GhRelease[]>;
+/** Read the org from GitHub: active repos, commits, issues, PRs, people. Read-only. */
+export declare function collectGithub(exec: Exec, org: string, since: string, o?: {
+    repos?: string[];
+    commits?: boolean;
+    log?: (s: string) => void;
+}): Promise<Collected>;
+/**
+ * Default channel mapping: repos grouped by name prefix (`myshow-room`,
+ * `myshow-video` -> #myshow); a repo that dominates a big group, or an active
+ * singleton, gets its own channel; quiet singletons go to #general; at most
+ * `maxChannels` channels besides #general. The plan is a starting point: edit it.
+ */
+export declare function defaultChannels(repos: RepoData[], maxChannels?: number): PlanChannel[];
+/** People from commits, issues and PRs; roles inferred; bots excluded. */
+export declare function inferPeople(c: Collected, channels: PlanChannel[]): {
+    people: PlanPerson[];
+    bots: string[];
+    unlinked: string[];
+};
+export declare function buildPlan(c: Collected, now?: Date): Plan;
+export declare function readPlan(file: string): Plan;
+/** {channel: {login: {commits}}} from the plan's per-person commits by repo (bots excluded). */
+export declare function channelStats(plan: Plan): Record<string, Record<string, {
+    commits: number;
+}>>;
+type Counts = Record<string, number>;
+/** Push plan + items to the hub in chunks; the last request records the sync time. */
+export declare function pushToHub(admin: Client, source: string, o: {
+    plan?: Plan;
+    items: GhItem[];
+    archive?: GhItem[];
+    stats?: Record<string, unknown>;
+    syncAt: string;
+    since: string;
+    ranges?: Record<string, unknown>;
+    releases?: GhRelease[];
+}): Promise<{
+    counts: Counts;
+    people: any[];
+    skipped: string[];
+    channels: any[];
+}>;
+/** One set of numbers for the dry-run header and the "Would import" line. */
+export declare function selectionCounts(sel: Selection): {
+    read: number;
+    issues: number;
+    prs: number;
+    items: number;
+    open: number;
+    recently_closed: number;
+    archived: number;
+    too_old: number;
+    excluded: number;
+};
+export declare function selectionLine(sel: Selection, channels: number): string;
+export declare function planSummary(plan: Plan, file?: string, sel?: Selection): string;
+export interface CmdIo {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out: (s: string) => void;
+    err: (s: string) => void;
+    exec?: Exec;
+    fetch?: import('./client.js').FetchLike;
+    now?: () => number;
+}
+/** `ach admin import github` */
+export declare function importGithub(values: Record<string, unknown>, positionals: string[], io: CmdIo, admin: () => Client): Promise<number>;
+/** --every 5m / 30s / 1h -> milliseconds (at least 1 minute unless ACH_SYNC_MIN_MS allows less, for tests). */
+export declare function parseEvery(v: string, env?: NodeJS.ProcessEnv): number;
+/**
+ * `ach admin sync github [--every 5m [--runs N]]`: one sync, or a loop (a failed
+ * run is reported and the loop goes on). The hub dedupes events, so a repeated
+ * sync never notifies twice.
+ */
+export declare function syncGithub(values: Record<string, unknown>, positionals: string[], io: CmdIo, admin: () => Client): Promise<number>;
+export declare function inviteMessage(name: string, link: string, workspace?: string, assigned?: number): string;
+/** The exact login that grants missing user scopes (lark-cli's own syntax; scopes add up across logins). */
+export declare function larkScopeHint(scopes?: string[]): string;
+/** Missing scopes named in a lark-cli error (JSON `missing_scopes`, or the scope named in the text). */
+export declare function larkMissingScopes(out: string): string[];
+/**
+ * `ach admin invite --feishu [--people a,b] [--map login=ou_x ...] [--yes]`
+ * `ach admin invite --people a,b --yes` (no Feishu: print the links to copy)
+ * Without --yes nothing is minted or sent: the messages are previewed.
+ */
+export declare function invitePeople(values: Record<string, unknown>, io: CmdIo, admin: () => Client): Promise<number>;
+export {};