flavor-code 1.2.1

package/dist/trace/replay.d.ts

@@ -0,0 +1,3 @@
+import { type TraceRecord } from "./schema.js";
+export declare function replayTrace(path: string, sessionId?: string): Promise<TraceRecord[]>;
+export declare function replayOutputEvents(path: string, sessionId?: string): AsyncIterable<unknown>;

package/dist/trace/schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const TraceKindSchema: z.ZodEnum<{
+    command: "command";
+    history: "history";
+    output: "output";
+    queue: "queue";
+    response: "response";
+    verification: "verification";
+}>;
+export type TraceKind = z.infer<typeof TraceKindSchema>;
+export declare const TraceRecordSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    kind: z.ZodEnum<{
+        command: "command";
+        history: "history";
+        output: "output";
+        queue: "queue";
+        response: "response";
+        verification: "verification";
+    }>;
+    payload: z.ZodUnknown;
+}, z.core.$strict>;
+export type TraceRecord = z.infer<typeof TraceRecordSchema>;

package/dist/ui/commands.d.ts

@@ -0,0 +1,67 @@
+export declare const MVP_COMMANDS: readonly ["model", "init", "config", "login", "permissions", "skills", "plugins", "hooks", "tasks", "finish", "compact", "clear", "help", "exit", "audit", "usage", "loop", "goal", "mcp", "ide", "memory", "remember", "forget", "checkpoint", "tree", "rewind", "unrevert", "fork"];
+export declare const COMMAND_DESCRIPTIONS: Record<(typeof MVP_COMMANDS)[number], string>;
+export type PermissionCommandMode = PermissionMode;
+export type ModelRole = "main" | "subagent";
+export type McpSlashCommand = {
+    name: "mcp";
+    action: "status";
+} | {
+    name: "mcp";
+    action: "tools" | "reconnect";
+    target: string;
+} | {
+    name: "mcp";
+    action: "enable" | "disable";
+    target: string;
+};
+export type SlashCommand = {
+    name: "model";
+    role: ModelRole;
+    modelId: string;
+} | {
+    name: "permissions";
+    mode: PermissionCommandMode;
+} | {
+    name: "plugin";
+    command: string;
+    args: string[];
+} | {
+    name: "skill";
+    skill: string;
+    prompt: string;
+} | {
+    name: "loop";
+    goal: string;
+} | {
+    name: "goal";
+    goal: string;
+} | {
+    name: "remember";
+    type: MemoryType;
+    text: string;
+} | {
+    name: "forget";
+    query: string;
+} | {
+    name: "checkpoint";
+    label?: string;
+} | {
+    name: "rewind" | "fork";
+    nodeId: string;
+} | McpSlashCommand | {
+    name: Exclude<(typeof MVP_COMMANDS)[number], "model" | "permissions" | "audit" | "loop" | "goal" | "mcp" | "remember" | "forget" | "checkpoint" | "rewind" | "fork">;
+} | {
+    name: "audit";
+    toolFilter?: string | undefined;
+} | {
+    name: "unknown";
+    input: string;
+    suggestions: string[];
+} | {
+    name: "invalid";
+    command: string;
+    message: string;
+};
+export declare function parseSlashCommand(input: string, dynamicCommands?: readonly string[], skillCommands?: readonly string[]): SlashCommand | null;
+import { type PermissionMode } from "../config/schema.js";
+import { type MemoryType } from "../memory/types.js";

package/dist/ui/session.d.ts

@@ -0,0 +1,126 @@
+import type { AgentEvent } from "../agent/types.js";
+import type { HookBus } from "../hooks/bus.js";
+import type { PermissionMode } from "../permissions/engine.js";
+import type { SkillMetadata } from "../skills/registry.js";
+import { type McpSlashCommand, type ModelRole } from "./commands.js";
+import type { QuestionBridge } from "../tools/ask-user-question.js";
+import type { MemoryType } from "../memory/types.js";
+import { type AgentQueueSnapshot } from "../agent/message-queue.js";
+import type { SessionTreeNode } from "../session/tree.js";
+import { type ModelContentBlock, type ModelMessage } from "../models/types.js";
+import type { IdeEditorContext } from "../ide/client.js";
+export interface SessionApprovalRequest {
+    id: string;
+    agent: "main" | "subagent";
+    tool: string;
+    reason?: string;
+    paths?: readonly string[];
+    command?: string;
+    args?: readonly string[];
+    cwd?: string;
+}
+export type SessionOutput = AgentEvent | {
+    type: "notice";
+    message: string;
+} | {
+    type: "queued-prompt";
+    prompt: string;
+} | {
+    type: "write-start";
+    id: string;
+    path: string;
+    before: string;
+    totalBytes: number;
+} | {
+    type: "write-delta";
+    id: string;
+    delta: string;
+} | {
+    type: "write-ready";
+    id: string;
+} | {
+    type: "write-cancelled";
+    id: string;
+} | {
+    type: "approval-request";
+    request: SessionApprovalRequest;
+} | {
+    type: "approval-cleared";
+    id?: string;
+} | {
+    type: "clear";
+} | {
+    type: "exit";
+};
+export interface SessionServices {
+    hooks: HookBus;
+    workspace: string;
+    mainModel(): string;
+    subagentModel(): string;
+    llmServiceName?(): string | undefined;
+    permissionMode(): PermissionMode;
+    run(prompt: string, signal: AbortSignal, options?: {
+        getSteeringMessages(): readonly string[];
+        initialUserMessage?: Extract<ModelMessage, {
+            role: "user";
+        }>;
+        additionalContext?: string;
+    }): AsyncIterable<AgentEvent>;
+    runSkill(skill: string, prompt: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    runLoop(goal: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    runGoal(goal: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    mcp(command: McpSlashCommand, signal: AbortSignal): Promise<string>;
+    ide?(): Promise<string>;
+    ideContext?(): Promise<IdeEditorContext | undefined>;
+    setModel(role: ModelRole, modelId: string): void | Promise<void>;
+    setPermissionMode(mode: PermissionMode): void | Promise<void>;
+    compact(signal?: AbortSignal): Promise<boolean>;
+    initialize(): Promise<{
+        path: string;
+        created: boolean;
+    }>;
+    config(): unknown;
+    skills(): Promise<readonly SkillMetadata[]>;
+    reloadSkills?(): Promise<void>;
+    plugins(): readonly unknown[];
+    hooksStatus(): readonly unknown[];
+    tasks(): unknown;
+    audit(toolFilter?: string): string | Promise<string>;
+    usage(): string | Promise<string>;
+    cancelActiveTask(): void | Promise<void>;
+    clearContext(): void | Promise<void>;
+    checkpoint?(label?: string): Promise<SessionTreeNode>;
+    tree?(): readonly SessionTreeNode[];
+    rewind?(nodeId: string): Promise<void>;
+    unrevert?(): Promise<void>;
+    fork?(nodeId: string): Promise<void>;
+    memory(): Promise<string>;
+    refreshMemory?(): Promise<void>;
+    remember(type: MemoryType, text: string): Promise<string>;
+    forget(query: string): Promise<string>;
+    finishTask(): Promise<string>;
+    pluginCommands(): readonly string[];
+    runPluginCommand(name: string, args: readonly string[], signal: AbortSignal): Promise<unknown>;
+    output(event: SessionOutput): void;
+    questions: QuestionBridge;
+    login(): Promise<string>;
+}
+export interface MultimodalSessionInput {
+    text: string;
+    content: ModelContentBlock[];
+}
+export declare class FlavorSession {
+    #private;
+    constructor(services: SessionServices);
+    get active(): boolean;
+    queueSnapshot(): AgentQueueSnapshot;
+    clearQueue(): AgentQueueSnapshot;
+    whenIdle(): Promise<void>;
+    steer(input: string): void;
+    followUp(input: string): void;
+    start(): Promise<void>;
+    submit(input: string): Promise<void>;
+    submit(input: MultimodalSessionInput): Promise<void>;
+    interrupt(): "cancelled" | "exit";
+    close(): Promise<void>;
+}

package/dist/ui/transcript.d.ts

@@ -0,0 +1,89 @@
+import type { SessionOutput } from "./session.js";
+import type { TaskSnapshot } from "../agent/types.js";
+import type { ToolPresentation } from "../tools/types.js";
+import { type ModelContent } from "../models/types.js";
+export interface TranscriptTurn {
+    id: number;
+    kind?: "compaction";
+    submittedAt?: string;
+    completedAt?: string;
+    prompt: string;
+    assistantText: string;
+    statusLines: string[];
+    blocks: TranscriptBlock[];
+    taskSnapshot?: TaskSnapshot;
+    suppressedTaskIds?: string[];
+}
+export interface TranscriptHistoryMessage {
+    readonly role: "user" | "assistant" | "tool";
+    readonly content: ModelContent;
+    readonly toolCallId?: string | undefined;
+    readonly toolCalls?: readonly {
+        id: string;
+        name: string;
+        input: unknown;
+    }[] | undefined;
+}
+export interface TranscriptCompactBoundary {
+    readonly summary: string;
+    readonly compactedAt: string;
+}
+export interface TranscriptToolDetails {
+    readonly name: string;
+    readonly input: unknown;
+    readonly result?: import("../tools/types.js").ToolResult;
+}
+export type TranscriptBlock = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "status";
+    id: string;
+    state: "running" | "completed" | "failed" | "cancelled" | "info";
+    tone?: "retry" | "warning";
+    text: string;
+    hint?: string;
+    task?: {
+        subject: string;
+        activeForm: string;
+        role: "main" | "subagent";
+    };
+    activity?: "model";
+    presentation?: ToolPresentation;
+    tool?: TranscriptToolDetails;
+    details?: string;
+    progress?: number;
+    startedAt?: number;
+    elapsedMs?: number;
+};
+export interface TranscriptState {
+    completed: TranscriptTurn[];
+    active?: TranscriptTurn;
+    nextId: number;
+    taskSnapshot?: TaskSnapshot;
+}
+export type TranscriptAction = {
+    type: "hydrate";
+    messages: readonly TranscriptHistoryMessage[];
+    compact?: TranscriptCompactBoundary;
+} | {
+    type: "restore";
+    state: TranscriptState;
+} | {
+    type: "submit";
+    prompt: string;
+} | {
+    type: "session";
+    event: SessionOutput;
+} | {
+    type: "submit-error";
+    message: string;
+} | {
+    type: "finish";
+} | {
+    type: "clear";
+};
+export declare function createTranscriptState(): TranscriptState;
+export declare function transcriptReducer(state: TranscriptState, action: TranscriptAction): TranscriptState;
+export declare function transcriptFromLegacyConversation(messages: readonly TranscriptHistoryMessage[], compact?: TranscriptCompactBoundary): TranscriptState;
+export declare function restoreTranscriptState(state: TranscriptState): TranscriptState;

package/dist/utils/async.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Race a promise against an AbortSignal. If the signal fires before the
+ * promise settles the returned promise rejects with the signal's reason.
+ */
+export declare function awaitWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/utils/envUtils.d.ts

@@ -0,0 +1 @@
+export declare function isEnvTruthy(value: string | boolean | undefined): boolean;

package/dist/utils/error.d.ts

@@ -0,0 +1,2 @@
+/** Extract a human-readable message from any error value. */
+export declare function message(error: unknown): string;

package/dist/utils/execFileNoThrow.d.ts

@@ -0,0 +1,13 @@
+export interface ExecFileNoThrowOptions {
+    timeout?: number;
+    useCwd?: boolean;
+    env?: NodeJS.ProcessEnv;
+    stdin?: "ignore" | "inherit" | "pipe";
+    input?: string;
+}
+export declare function execFileNoThrow(file: string, args: string[], options?: ExecFileNoThrowOptions): Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+    error?: string;
+}>;

package/dist/utils/intl.d.ts

@@ -0,0 +1,18 @@
+export declare function getGraphemeSegmenter(): Intl.Segmenter;
+/**
+ * Detect the system locale as a BCP47 language tag (e.g. "zh-CN", "en-US").
+ * Uses Intl (available since Node 13) and falls back to POSIX locale
+ * environment variables on Unix systems.
+ */
+export declare function detectSystemLocale(): string;
+/**
+ * Resolve the effective language tag: explicit config wins, then system
+ * detection, and finally "en-US" as the ultimate default.
+ */
+export declare function resolveLanguage(explicit: string | undefined): string;
+/**
+ * Build a short instruction suffix that tells the agent which language to
+ * reply in.  When the tag is English we still emit it so the model knows
+ * the preference is explicit.
+ */
+export declare function languageInstruction(language: string): string;

package/dist/utils/json.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Parse a string as JSON.
+ *
+ * Returns the parsed value on success, or `null` when the string is not valid
+ * JSON.  Unlike the previous implementation this never returns the raw string,
+ * so callers can safely treat a null return as "not JSON" without risking a
+ * string masquerading as a parsed object downstream.
+ *
+ * DeepSeek and other third-party Anthropic-compatible providers have been
+ * observed returning tool-call arguments as double-encoded JSON strings
+ * (e.g. `"{\"path\": ...}"`) instead of a proper JSON object.  Callers
+ * should handle that at a higher level (see normalizeToolCallInput).
+ */
+export declare function parseJson(input: string): unknown;
+/** Result of a safe JSON parse that never throws. */
+export interface SafeJsonResult {
+    ok: true;
+    value: unknown;
+}
+export interface SafeJsonError {
+    ok: false;
+    error: string;
+}
+export type SafeJson = SafeJsonResult | SafeJsonError;
+/** Parse a string as JSON, returning a discriminated union on failure. */
+export declare function safeParseJson(input: string): SafeJson;
+/**
+ * Normalize tool-call input that arrived from a model API stream.
+ *
+ * Model providers (especially third-party Anthropic-compatible ones like
+ * DeepSeek) may return tool-call arguments in one of these forms:
+ *
+ * 1. **Object** — non-streaming / fallback paths (pass through).
+ * 2. **JSON string** (`'{"path":"x","content":"y"}'`) — normal streaming.
+ * 3. **Double-encoded JSON string** (`'"{\\"path\\":...}"'`) — some providers
+ *    nest the JSON inside an extra string layer.
+ * 4. **Empty string** — treated as `{}` for no-argument tools.
+ * 5. **Malformed JSON** — rejected with the parse failure preserved.
+ *
+ * This function recursively unwraps nested strings until it reaches an object
+ * or exhausts the unwrapping depth. Invalid input throws instead of silently
+ * becoming `{}`, because that destroys the provider-side failure evidence.
+ */
+export declare function normalizeToolCallInput(input: unknown, maxDepth?: number): Record<string, unknown>;

package/dist/utils/log.d.ts

@@ -0,0 +1,28 @@
+export declare function logError(error: unknown): void;
+export declare function usageLogPath(): string;
+export declare function setUsageSession(sessionId: string): void;
+export declare function currentUsageSession(): string;
+export declare function appendUsageLog(line: string): Promise<void>;
+export interface AuditEntry {
+    timestamp: string;
+    sessionId: string;
+    event: string;
+    tool?: string | undefined;
+    model?: string | undefined;
+    agent?: string | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    attempt?: number | undefined;
+    maxAttempts?: number | undefined;
+    purpose?: string | undefined;
+    repairAttempt?: number | undefined;
+    repairMaxAttempts?: number | undefined;
+    input?: unknown;
+}
+export declare class AuditLogger {
+    #private;
+    constructor(workspace: string);
+    get path(): string;
+    append(entry: AuditEntry): Promise<void>;
+    close(): void;
+}

package/dist/utils/redact.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Strip well-known API key patterns from an arbitrary error string so it is
+ * safe to display to the user or write to logs.
+ */
+export declare function redactErrorText(text: string): string;
+/**
+ * Replace every occurrence of each secret string inside `input` with
+ * `[redacted]`. Used for diagnostics that may contain configured API keys.
+ */
+export declare function redactSecrets(input: string, secrets: readonly string[]): string;

package/dist/utils/usage-summary.d.ts

@@ -0,0 +1,34 @@
+export interface UsageEntry {
+    event: "flavor-usage";
+    sessionId?: string | undefined;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    totalInputTokens: number;
+    cacheHitRatio: number;
+}
+export interface UsageModelStats {
+    provider: string;
+    model: string;
+    requests: number;
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    totalInputTokens: number;
+    minHitRatio: number;
+    averageHitRatio: number;
+}
+export interface UsageSummary {
+    requests: number;
+    sessionId: string | undefined;
+    byModel: UsageModelStats[];
+    totalInputTokens: number;
+    totalCacheReadTokens: number;
+    /** Share of total input tokens served from cache (0 when nothing was sent). */
+    cacheShare: number;
+}
+export declare function parseUsageEntries(raw: string): UsageEntry[];
+export declare function summarizeUsage(entries: readonly UsageEntry[]): UsageSummary;
+export declare function formatUsageSummary(summary: UsageSummary): string;

package/dist/utils/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve the package version from the nearest package.json, walking up from
+ * this module. This stays correct in the source tree, in the bundled
+ * `dist/` output, and in an installed npm package.
+ */
+export declare function packageVersion(): string;

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "flavor-code",
+  "version": "1.2.1",
+  "author": "YachuanWzh",
+  "type": "module",
+  "main": "dist/desktop/main.js",
+  "bin": {
+    "flavor": "dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/desktop/main.js",
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "import": "./dist/sdk/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "技术方案报告.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "npm run build:icons && npm run build:cli && npm run build:desktop",
+    "build:icons": "node scripts/build-icons.mjs",
+    "build:cli": "tsup && tsc -p tsconfig.sdk.json && node -e \"require('fs').cpSync('src/init/codeisland','dist/codeisland',{recursive:true})\"",
+    "build:desktop": "npm run build:desktop:main && npm run build:desktop:renderer",
+    "build:desktop:main": "tsup --config tsup.desktop.config.ts",
+    "build:desktop:renderer": "vite build --config vite.desktop.config.ts",
+    "vscode:build": "tsup --config tsup.vscode.config.ts",
+    "vscode:typecheck": "tsc --noEmit -p tsconfig.vscode.json",
+    "ide:install": "node scripts/install-vscode-extension.mjs --ide auto",
+    "qoder:install": "node scripts/install-vscode-extension.mjs --ide qoder",
+    "vscode:install": "node scripts/install-vscode-extension.mjs --ide code",
+    "desktop:dev": "npm run build:desktop:main && node scripts/desktop-dev.mjs",
+    "desktop:start": "npm run build && electron .",
+    "desktop:pack": "npm run build && electron-builder --win --dir",
+    "desktop:dist": "npm run build && electron-builder --win nsis",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "smoke:install": "node scripts/smoke-install.mjs",
+    "prepack": "npm run build"
+  },
+  "build": {
+    "appId": "dev.flavorcode.desktop",
+    "productName": "Flavor Code",
+    "asar": true,
+    "icon": "assets/icon",
+    "directories": {
+      "output": "release"
+    },
+    "files": [
+      "dist/**/*",
+      "assets/icon.png",
+      "package.json",
+      "README.md",
+      "LICENSE"
+    ],
+    "win": {
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        }
+      ],
+      "artifactName": "Flavor-Code-${version}-${arch}.${ext}"
+    },
+    "nsis": {
+      "oneClick": false,
+      "allowToChangeInstallationDirectory": true,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true
+    }
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.111.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@vscode/ripgrep": "^1.18.0",
+    "bidi-js": "^1.0.3",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "emoji-regex": "^10.6.0",
+    "flavor-code": "file:flavor-code-1.2.1.tgz",
+    "ignore": "^7.0.6",
+    "ink": "^7.1.0",
+    "lodash-es": "^4.17.23",
+    "marked": "^16.4.2",
+    "openai": "^6.46.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "semver": "^7.7.4",
+    "signal-exit": "4.1.0",
+    "supports-hyperlinks": "^4.4.0",
+    "typescript": "^7.0.2",
+    "usehooks-ts": "^3.1.1",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/vscode": "1.95.0",
+    "@vscode/vsce": "3.9.2",
+    "electron": "^42.7.0",
+    "electron-builder": "^26.15.3",
+    "sharp": "^0.35.3",
+    "tsup": "^8.5.1",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "allowScripts": {
+    "electron-winstaller@5.4.0": true,
+    "esbuild@0.27.7": true,
+    "electron@42.7.0": true
+  }
+}