@laxture/vibe-pm 0.1.0

package/dist/integration/dcp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Write DCP protection config (protectTags + protectedFilePatterns)
+ *
+ * Checks whether opencode.json/opencode.jsonc has a plugin config;
+ * both project-level and global-level are checked, and writes proceed if found.
+ */
+export declare function writeDcpConfig(projectDir: string): void;

package/dist/integration/index.d.ts

@@ -0,0 +1 @@
+export { writeDcpConfig } from './dcp.js';

package/dist/memory/errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Memory System error classes
+ */
+/** Thrown when attempting to create a second Task for a session that already has an active one */
+export declare class DuplicateTaskError extends Error {
+    constructor(sessionId: string);
+}
+/** Generic Data Layer error */
+export declare class MemorySystemError extends Error {
+    constructor(message: string);
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,3 @@
+export { MemorySystem } from './memory-system.js';
+export { DuplicateTaskError, MemorySystemError } from './errors.js';
+export type { Task, CreateTaskInput, Discussion, CreateDiscussionInput, StepTokenMetrics, IMemorySystem, StepTokenBreakdown, SubagentTokenMetrics, SessionTokenMetrics, } from './types.js';

package/dist/memory/memory-system.d.ts

@@ -0,0 +1,80 @@
+import type { CreateDiscussionInput, CreateTaskInput, Discussion, StepTokenMetrics, IMemorySystem, SessionTokenMetrics, StepTokenBreakdown, StepTransition, SubagentTokenMetrics, Task } from './types.js';
+import { ApiTelemetry, TokenCount } from '../token';
+/**
+ * vibe-pm's Structured Memory layer.
+ *
+ * Manages three categories of data via SQLite (better-sqlite3):
+ * - tasks: FSM-driven Task state
+ * - discussions: non-urgent Discussion items (async-time-friendly, async review)
+ * - stepTokenMetrics: per-Step metrics (Token consumption, dwell time, etc.)
+ */
+export declare class MemorySystem implements IMemorySystem {
+    private db;
+    private stmtInsertTask;
+    private stmtGetTaskBySession;
+    private stmtGetActiveTaskBySession;
+    private stmtUpdateTaskStep;
+    private stmtCloseTask;
+    private stmtListActiveTasks;
+    private stmtGetTaskById;
+    private stmtUpdateTaskTransitions;
+    private stmtInsertDiscussion;
+    private stmtGetDiscussionsBySession;
+    private stmtGetAllDiscussions;
+    private stmtResolveDiscussion;
+    private stmtGetMetricsBySessionStep;
+    private stmtUpdateMetrics;
+    private stmtUpsertMetrics;
+    private stmtInsertMetrics;
+    private stmtGetMetricsBySession;
+    private stmtGetMetricsByFlow;
+    private stmtGetClosedTasksBySession;
+    private stmtCheckDupUserRequest;
+    private stmtInitSessionTokens;
+    private stmtGetSessionTokens;
+    private stmtUpsertSessionTokens;
+    private stmtUpsertSubagentTokens;
+    private stmtGetSubagentTokens;
+    /**
+     * Initialize database connection and table schema.
+     *
+     * Creates a SQLite database file in the specified directory and sets up tables.
+     * Must be called once before use.
+     *
+     * @param dataDir Directory for storing database files (typically `.vibe-pm/`)
+     */
+    init(dataDir: string): Promise<void>;
+    createTask(input: CreateTaskInput): Promise<Task>;
+    checkDuplicateUserRequest(sessionId: string, userRequest: string): Promise<boolean>;
+    getTask(sessionId: string): Promise<Task | null>;
+    getActiveTask(sessionId: string): Promise<Task | null>;
+    updateStep(id: string, step: string, stepName: string): Promise<void>;
+    closeTask(id: string): Promise<void>;
+    listActiveTasks(): Promise<Task[]>;
+    appendStepTransition(id: string, transition: StepTransition): Promise<void>;
+    createDiscussion(input: CreateDiscussionInput): Promise<Discussion>;
+    getDiscussions(sessionId: string): Promise<Discussion[]>;
+    getUnresolvedDiscussions(): Promise<Discussion[]>;
+    resolveDiscussion(id: string, decision: string): Promise<void>;
+    listDiscussions(filter?: {
+        priority?: string;
+        unresolved?: boolean;
+    }): Promise<Discussion[]>;
+    recordStepTokens(sessionId: string, flow: string, step: string, stepName: string, tokenCount: TokenCount): Promise<void>;
+    incrementStepCount(sessionId: string, flow: string, step: string, stepName: string, taskSummary: string): Promise<void>;
+    recordStepExit(sessionId: string, step: string): Promise<void>;
+    getStepTokenMetrics(sessionId: string): Promise<StepTokenMetrics[]>;
+    getStepTokenMetricsByFlow(flow: string): Promise<StepTokenMetrics[]>;
+    initSessionTokens(sessionId: string): Promise<void>;
+    recordSessionTokens(sessionId: string, tokenCount: TokenCount, apiTelemetry?: ApiTelemetry): Promise<void>;
+    getSessionTokens(sessionId: string): Promise<SessionTokenMetrics | null>;
+    getLastClosedTask(sessionId: string): Promise<Task | null>;
+    getStepTokenBreakdown(sessionId: string): Promise<StepTokenBreakdown[]>;
+    recordSubagentTokens(sessionId: string, parentSessionId: string, tokenCount: TokenCount, apiTelemetry?: ApiTelemetry): Promise<void>;
+    getSubagentTokens(parentSessionId: string): Promise<SubagentTokenMetrics[]>;
+    private rowToTask;
+    private rowToDiscussion;
+    private rowToStepTokenMetrics;
+    private rowToSessionTokenMetrics;
+    private rowToSubagentTokenMetrics;
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Memory System entity and interface definitions
+ *
+ * Manages three categories of Structured Memory: Task (Task State),
+ * Discussion (Discussion items), StepTokenMetrics (Flow Metrics).
+ */
+import { ApiTelemetry, TokenCount } from '../token';
+/** Step transition record: written once per setStep call, appended in chronological order */
+export interface StepTransition {
+    /** Source Step ID */
+    fromStep: string;
+    /** Destination Step ID */
+    toStep: string;
+    /** Transition timestamp (ISO 8601) */
+    at: string;
+}
+export interface Task {
+    id: string;
+    sessionId: string;
+    flow: string;
+    currentStep: string;
+    currentStepName: string;
+    startAt: string;
+    /** Task end time (ISO 8601), written by closeTask */
+    endAt?: string;
+    closed: boolean;
+    summary: string;
+    /** User's original request content (text within <user-request> tag), used for deduplication */
+    userRequest?: string;
+    /** Step transition history in chronological order. From the second record onward, dwell time can be computed from the `at` delta of adjacent records. */
+    stepTransitions?: StepTransition[];
+}
+export interface CreateTaskInput {
+    sessionId: string;
+    flow: string;
+    currentStep: string;
+    currentStepName: string;
+    startAt: string;
+    summary: string;
+    userRequest?: string;
+}
+export interface Discussion {
+    id: string;
+    fromSessionId: string;
+    priority: 'high' | 'medium' | 'low';
+    importance: 1 | 2 | 3 | 4 | 5;
+    severity: 1 | 2 | 3 | 4 | 5;
+    issue: string;
+    reason: string;
+    solution: string;
+    decision?: string;
+    taskSummary: string;
+    createdAt: string;
+    resolvedAt?: string;
+}
+export interface CreateDiscussionInput {
+    fromSessionId: string;
+    priority: 'high' | 'medium' | 'low';
+    importance: 1 | 2 | 3 | 4 | 5;
+    severity: 1 | 2 | 3 | 4 | 5;
+    issue: string;
+    reason: string;
+    solution: string;
+    taskSummary?: string;
+}
+export interface StepTokenMetrics {
+    id: string;
+    sessionId: string;
+    flow: string;
+    step: string;
+    stepName: string;
+    stepInCount: number;
+    tokensConsumed: number;
+    /** Token distribution by source, independently accumulated per source */
+    tokensBySource: Record<string, number>;
+    taskSummary: string;
+}
+/** Per-Step Token summary */
+export interface StepTokenBreakdown {
+    step: string;
+    stepName: string;
+    stepInCount: number;
+    tokensConsumed: number;
+}
+/** Session-level Token storage — hierarchical column design */
+export interface SessionTokenMetrics {
+    sessionId: string;
+    /** Base types */
+    user: number;
+    assistant: number;
+    /** By purpose */
+    flowControl: number;
+    text: number;
+    tool: number;
+    reasoning: number;
+    /** LLM API telemetry (written only when the LLM returns data) */
+    apiInput: number;
+    apiOutput: number;
+    apiReasoning: number;
+    apiCacheRead: number;
+    apiCacheWrite: number;
+    /** Calibration factor = (apiInput + apiCacheRead + apiCacheWrite) / (user + assistant) */
+    scaleFactor: number;
+    /** Timestamp */
+    startedAt: string;
+    updatedAt: string;
+}
+/** Input parameters for recordSessionTokens — categorized by TokenCounter's 6 sources */
+export interface RecordSessionTokensInput {
+    text: number;
+    user: number;
+    assistant: number;
+    flowControl: number;
+    tool: number;
+    reasoning: number;
+}
+/** Subagent Token storage — distinguished by role + API telemetry */
+export interface SubagentTokenMetrics {
+    sessionId: string;
+    parentSessionId: string;
+    user: number;
+    assistant: number;
+    apiInput: number;
+    apiOutput: number;
+    apiReasoning: number;
+    apiCacheRead: number;
+    apiCacheWrite: number;
+}
+export interface IMemorySystem {
+    createTask(input: CreateTaskInput): Promise<Task>;
+    getTask(sessionId: string): Promise<Task | null>;
+    getActiveTask(sessionId: string): Promise<Task | null>;
+    updateStep(id: string, step: string, stepName: string): Promise<void>;
+    closeTask(id: string): Promise<void>;
+    listActiveTasks(): Promise<Task[]>;
+    createDiscussion(input: CreateDiscussionInput): Promise<Discussion>;
+    getDiscussions(sessionId: string): Promise<Discussion[]>;
+    getUnresolvedDiscussions(): Promise<Discussion[]>;
+    resolveDiscussion(id: string, decision: string): Promise<void>;
+    listDiscussions(filter?: {
+        priority?: string;
+        unresolved?: boolean;
+    }): Promise<Discussion[]>;
+    recordStepTokens(sessionId: string, flow: string, step: string, stepName: string, tokenCount: TokenCount): Promise<void>;
+    incrementStepCount(sessionId: string, flow: string, step: string, stepName: string, taskSummary: string): Promise<void>;
+    recordStepExit(sessionId: string, step: string): Promise<void>;
+    getStepTokenMetrics(sessionId: string): Promise<StepTokenMetrics[]>;
+    getStepTokenMetricsByFlow(flow: string): Promise<StepTokenMetrics[]>;
+    getLastClosedTask(sessionId: string): Promise<Task | null>;
+    getStepTokenBreakdown(sessionId: string): Promise<StepTokenBreakdown[]>;
+    initSessionTokens(sessionId: string): Promise<void>;
+    recordSessionTokens(sessionId: string, tokenCount: TokenCount, apiTelemetry?: ApiTelemetry): Promise<void>;
+    getSessionTokens(sessionId: string): Promise<SessionTokenMetrics | null>;
+    recordSubagentTokens(sessionId: string, parentSessionId: string, tokenCount: TokenCount, apiTelemetry?: ApiTelemetry): Promise<void>;
+    getSubagentTokens(parentSessionId: string): Promise<SubagentTokenMetrics[]>;
+    init(dataDir: string): Promise<void>;
+}

package/dist/template/index.d.ts

@@ -0,0 +1,3 @@
+export { scanTemplates, installTemplate, uninstallFlow, listInstalledFlows, TemplateConflictError, } from './template-manager.js';
+export { writeDcpConfig } from '../integration/index.js';
+export type { TemplateMeta } from './types.js';

package/dist/template/template-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Template Manager
+ *
+ * Pure file-operation module: Template Scanning, Installation
+ * (including command file generation, regulation auto-install),
+ * Uninstall (including command file cleanup).
+ * Zero external dependencies, reads/writes filesystem by convention paths.
+ */
+import type { TemplateMeta } from './types.js';
+export declare class TemplateConflictError extends Error {
+    constructor(flowName: string);
+}
+export declare function scanTemplates(projectDir: string): TemplateMeta[];
+export interface InstallResult {
+    flowPath: string;
+    regulationPaths: string[];
+    codingStylePaths: string[];
+    dictionaryPath: string | null;
+}
+export declare function installTemplate(projectDir: string, templateId: string, options?: {
+    programmingLanguages?: string[];
+    overwrite?: boolean;
+    locale?: string;
+}): InstallResult;
+export declare function uninstallFlow(projectDir: string, flowName: string): void;
+export declare function listInstalledFlows(projectDir: string): string[];

package/dist/template/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Template Manager type definitions
+ */
+export interface TemplateMeta {
+    id: string;
+    name: string;
+    category: string;
+    description: string;
+    version: string;
+    /** Associated slash command name (e.g., /pm-research) */
+    command: string;
+    /** Template file path (flow.md) */
+    flowPath: string;
+    /** Template bundle root directory */
+    bundleDir: string;
+}

package/dist/token/backends/anthropic.d.ts

@@ -0,0 +1,5 @@
+import type { TokenizerBackend } from '../types.js';
+export declare class AnthropicBackend implements TokenizerBackend {
+    countTokens(text: string): number;
+    dispose(): void;
+}

package/dist/token/backends/llama.d.ts

@@ -0,0 +1,7 @@
+import type { TokenizerBackend } from '../types.js';
+export declare class LlamaBackend implements TokenizerBackend {
+    private mode;
+    constructor(modelID: string);
+    countTokens(text: string): number;
+    dispose(): void;
+}

package/dist/token/backends/tiktoken.d.ts

@@ -0,0 +1,7 @@
+import type { TokenizerBackend } from '../types.js';
+export declare class TiktokenBackend implements TokenizerBackend {
+    private encoder;
+    constructor(modelID: string);
+    countTokens(text: string): number;
+    dispose(): void;
+}

package/dist/token/index.d.ts

@@ -0,0 +1,3 @@
+export { TokenCounter } from './token-counter.js';
+export type { TokenCount, MessagePack, ApiTelemetry, ModelInfo, TokenizerBackend, } from './types.js';
+export { resolveBackend } from './model-registry.js';

package/dist/token/model-registry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ModelRegistry — model → backend mapping table
+ *
+ * Selects the correct TokenizerBackend based on providerID + modelID.
+ * Unknown models fall back to cl100k_base (OpenAI GPT-4 encoding).
+ */
+import type { ModelInfo, TokenizerBackend } from './types.js';
+/** Create the corresponding tokenizer backend based on model info */
+export declare function resolveBackend(info: ModelInfo): TokenizerBackend;

package/dist/token/token-counter.d.ts

@@ -0,0 +1,17 @@
+import type { MessagePack, TokenCount, ModelInfo } from './types.js';
+export declare class TokenCounter {
+    private backend;
+    constructor(info: ModelInfo);
+    /** Encode text and return token count. Empty/whitespace returns 0 directly. */
+    countTokens(text: string): number;
+    /**
+     * Classify part token source by part.type and content.
+     */
+    private classifyPartType;
+    /**
+     * Count tokens in a message and classify by source.
+     */
+    countContextTokens(message: MessagePack): TokenCount;
+    /** Release backend resources */
+    dispose(): void;
+}

package/dist/token/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Token counting module type definitions
+ */
+import type { Message, Part } from '@opencode-ai/sdk';
+/** Token count classified by 6 sources */
+export interface TokenCount {
+    user: number;
+    assistant: number;
+    text: number;
+    flowControl: number;
+    tool: number;
+    reasoning: number;
+}
+export interface MessagePack {
+    info: Message;
+    parts: Part[];
+}
+/** LLM API telemetry data — aligned with @opencode-ai/sdk tokens type */
+export interface ApiTelemetry {
+    input: number;
+    output: number;
+    reasoning: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+/** Model identifier — used to select the correct tokenizer */
+export interface ModelInfo {
+    providerID: string;
+    modelID: string;
+}
+/** Tokenizer backend interface — each model family implements its own counting logic */
+export interface TokenizerBackend {
+    /** Encode text and return token count (empty/whitespace returns 0) */
+    countTokens(text: string): number;
+    /** Release backend resources */
+    dispose(): void;
+}

package/dist/tui/components/collapsible.d.ts

@@ -0,0 +1,9 @@
+import type { RGBA } from '@opentui/core';
+import { type JSX } from 'solid-js';
+export interface CollapsibleProps {
+    title: string;
+    defaultCollapsed?: boolean;
+    titleColor?: RGBA;
+    children: JSX.Element;
+}
+export declare function Collapsible(props: CollapsibleProps): JSX.Element;

package/dist/tui/components/empty-state.d.ts

@@ -0,0 +1,7 @@
+import type { RGBA } from '@opentui/core';
+import type { JSX } from 'solid-js';
+export interface EmptyStateProps {
+    message?: string;
+    mutedColor: RGBA;
+}
+export declare function EmptyState(props: EmptyStateProps): JSX.Element;

package/dist/tui/data/task-status.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Task status data loading
+ *
+ * Loads status info for the current or previous task from IMemorySystem.
+ */
+import type { IMemorySystem } from '../../memory/types.js';
+import type { TaskStatusData } from '../types.js';
+/**
+ * Load task status data for the specified session.
+ *
+ * Query logic:
+ * 1. Check active task first → active state
+ * 2. No active task → check last closed task → last state
+ * 3. Neither found → empty state
+ */
+export declare function loadTaskStatus(memory: IMemorySystem, sessionId: string): Promise<TaskStatusData>;

package/dist/tui/data/token-data.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Token data loading
+ *
+ * Loads Session-level token distribution (source + step) from IMemorySystem.
+ * Session-level data comes from the session_tokens table, calibrated with display formulas.
+ * Step-level data comes from flowMetrics aggregation.
+ */
+import type { IMemorySystem } from '../../memory/types.js';
+import type { TokenData } from '../types.js';
+/**
+ * Load token distribution data for the specified session.
+ *
+ * Session-level tokens are read from the session_tokens table with display formulas applied.
+ * Step-level tokens are read from flowMetrics aggregation (unchanged).
+ */
+export declare function loadTokenData(memory: IMemorySystem, sessionId: string): Promise<TokenData>;

package/dist/tui/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * TUI extension module exports
+ *
+ * Exports TuiPluginModule for OpenCode TUI loading.
+ * OpenCode only reads the default export, not named exports.
+ * createTuiPlugin() is invoked immediately to produce a ready-to-use TuiPlugin function.
+ */
+import type { TuiPluginModule } from '@opencode-ai/plugin/tui';
+declare const plugin: TuiPluginModule & {
+    id: string;
+};
+export default plugin;
+export type * from './types.js';