homer-simpson 0.1.0

package/dist/tools/session-manager/storage.d.ts

@@ -0,0 +1,12 @@
+import type { SessionMessage, SessionInfo, TodoItem, SessionMetadata } from "./types";
+export interface GetMainSessionsOptions {
+    directory?: string;
+}
+export declare function getMainSessions(options: GetMainSessionsOptions): Promise<SessionMetadata[]>;
+export declare function getAllSessions(): Promise<string[]>;
+export declare function getMessageDir(sessionID: string): string;
+export declare function sessionExists(sessionID: string): boolean;
+export declare function readSessionMessages(sessionID: string): Promise<SessionMessage[]>;
+export declare function readSessionTodos(sessionID: string): Promise<TodoItem[]>;
+export declare function readSessionTranscript(sessionID: string): Promise<number>;
+export declare function getSessionInfo(sessionID: string): Promise<SessionInfo | null>;

package/dist/tools/session-manager/storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/session-manager/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare const session_list: ToolDefinition;
+export declare const session_read: ToolDefinition;
+export declare const session_search: ToolDefinition;
+export declare const session_info: ToolDefinition;

package/dist/tools/session-manager/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/session-manager/types.d.ts

@@ -0,0 +1,89 @@
+export interface SessionMessage {
+    id: string;
+    role: "user" | "assistant";
+    agent?: string;
+    time?: {
+        created: number;
+        updated?: number;
+    };
+    parts: MessagePart[];
+}
+export interface MessagePart {
+    id: string;
+    type: string;
+    text?: string;
+    thinking?: string;
+    tool?: string;
+    callID?: string;
+    input?: Record<string, unknown>;
+    output?: string;
+    error?: string;
+}
+export interface SessionInfo {
+    id: string;
+    message_count: number;
+    first_message?: Date;
+    last_message?: Date;
+    agents_used: string[];
+    has_todos: boolean;
+    has_transcript: boolean;
+    todos?: TodoItem[];
+    transcript_entries?: number;
+}
+export interface TodoItem {
+    id: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    priority?: string;
+}
+export interface SearchResult {
+    session_id: string;
+    message_id: string;
+    role: string;
+    excerpt: string;
+    match_count: number;
+    timestamp?: number;
+}
+export interface SessionMetadata {
+    id: string;
+    version?: string;
+    projectID: string;
+    directory: string;
+    title?: string;
+    parentID?: string;
+    time: {
+        created: number;
+        updated: number;
+    };
+    summary?: {
+        additions: number;
+        deletions: number;
+        files: number;
+    };
+}
+export interface SessionListArgs {
+    limit?: number;
+    offset?: number;
+    from_date?: string;
+    to_date?: string;
+    project_path?: string;
+}
+export interface SessionReadArgs {
+    session_id: string;
+    include_todos?: boolean;
+    include_transcript?: boolean;
+    limit?: number;
+}
+export interface SessionSearchArgs {
+    query: string;
+    session_id?: string;
+    case_sensitive?: boolean;
+    limit?: number;
+}
+export interface SessionInfoArgs {
+    session_id: string;
+}
+export interface SessionDeleteArgs {
+    session_id: string;
+    confirm: boolean;
+}

package/dist/tools/session-manager/utils.d.ts

@@ -0,0 +1,11 @@
+import type { SessionInfo, SessionMessage, SearchResult } from "./types";
+export declare function formatSessionList(sessionIDs: string[]): Promise<string>;
+export declare function formatSessionMessages(messages: SessionMessage[], includeTodos?: boolean, todos?: Array<{
+    id: string;
+    content: string;
+    status: string;
+}>): string;
+export declare function formatSessionInfo(info: SessionInfo): string;
+export declare function formatSearchResults(results: SearchResult[]): string;
+export declare function filterSessionsByDate(sessionIDs: string[], fromDate?: string, toDate?: string): Promise<string[]>;
+export declare function searchInSession(sessionID: string, query: string, caseSensitive?: boolean, maxResults?: number): Promise<SearchResult[]>;

package/dist/tools/session-manager/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/skill/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const TOOL_NAME: "skill";
+export declare const TOOL_DESCRIPTION_NO_SKILLS = "Load a skill to get detailed instructions for a specific task. No skills are currently available.";
+export declare const TOOL_DESCRIPTION_PREFIX = "Load a skill to get detailed instructions for a specific task.\n\nSkills provide specialized knowledge and step-by-step guidance.\nUse this when a task matches an available skill's description.";

package/dist/tools/skill/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./types";
+export { skill, createSkillTool } from "./tools";

package/dist/tools/skill/tools.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { SkillLoadOptions } from "./types";
+export declare function createSkillTool(options?: SkillLoadOptions): ToolDefinition;
+export declare const skill: ToolDefinition;

package/dist/tools/skill/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/skill/types.d.ts

@@ -0,0 +1,25 @@
+import type { SkillScope, LoadedSkill } from "../../features/opencode-skill-loader/types";
+import type { SkillMcpManager } from "../../features/skill-mcp-manager";
+export interface SkillArgs {
+    name: string;
+}
+export interface SkillInfo {
+    name: string;
+    description: string;
+    location?: string;
+    scope: SkillScope;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+}
+export interface SkillLoadOptions {
+    /** When true, only load from OpenCode paths (.opencode/skill/, ~/.config/opencode/skill/) */
+    opencodeOnly?: boolean;
+    /** Pre-merged skills to use instead of discovering */
+    skills?: LoadedSkill[];
+    /** MCP manager for querying skill-embedded MCP servers */
+    mcpManager?: SkillMcpManager;
+    /** Session ID getter for MCP client identification */
+    getSessionID?: () => string;
+}

package/dist/tools/skill-mcp/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_MCP_TOOL_NAME = "skill_mcp";
+export declare const SKILL_MCP_DESCRIPTION = "Invoke MCP server operations from skill-embedded MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.";

package/dist/tools/skill-mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./types";
+export { createSkillMcpTool } from "./tools";

package/dist/tools/skill-mcp/tools.d.ts

@@ -0,0 +1,11 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { SkillMcpManager } from "../../features/skill-mcp-manager";
+import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
+interface SkillMcpToolOptions {
+    manager: SkillMcpManager;
+    getLoadedSkills: () => LoadedSkill[];
+    getSessionID: () => string;
+}
+export declare function applyGrepFilter(output: string, pattern: string | undefined): string;
+export declare function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition;
+export {};

package/dist/tools/skill-mcp/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/skill-mcp/types.d.ts

@@ -0,0 +1,8 @@
+export interface SkillMcpArgs {
+    mcp_name: string;
+    tool_name?: string;
+    resource_name?: string;
+    prompt_name?: string;
+    arguments?: string;
+    grep?: string;
+}

package/dist/tools/slashcommand/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { slashcommand, createSlashcommandTool, discoverCommandsSync } from "./tools";

package/dist/tools/slashcommand/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { CommandInfo, SlashcommandToolOptions } from "./types";
+export declare function discoverCommandsSync(): CommandInfo[];
+export declare function createSlashcommandTool(options?: SlashcommandToolOptions): ToolDefinition;
+export declare const slashcommand: ToolDefinition;

package/dist/tools/slashcommand/types.d.ts

@@ -0,0 +1,24 @@
+import type { LoadedSkill, LazyContentLoader } from "../../features/opencode-skill-loader";
+export type CommandScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project";
+export interface CommandMetadata {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    model?: string;
+    agent?: string;
+    subtask?: boolean;
+}
+export interface CommandInfo {
+    name: string;
+    path?: string;
+    metadata: CommandMetadata;
+    content?: string;
+    scope: CommandScope;
+    lazyContentLoader?: LazyContentLoader;
+}
+export interface SlashcommandToolOptions {
+    /** Pre-loaded commands (skip discovery if provided) */
+    commands?: CommandInfo[];
+    /** Pre-loaded skills (skip discovery if provided) */
+    skills?: LoadedSkill[];
+}

package/dist/tools/spec-system/clarity-checker.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 명확성 판단 모듈
+ * 사용자 요청의 명확성/모호성을 판단
+ */
+import type { ClarityResult } from "./types";
+/**
+ * 요청의 명확성을 판단
+ * @param request 사용자 요청 텍스트
+ * @returns 명확성 판단 결과
+ */
+export declare function checkClarity(request: string): ClarityResult;
+/**
+ * AI 컨텍스트용 명확성 판단 프롬프트 생성
+ * @param request 사용자 요청
+ * @returns AI에게 전달할 판단 가이드
+ */
+export declare function generateClarityPrompt(request: string): string;
+/**
+ * 요청이 명확한지 빠르게 판단 (AI 호출 전 사전 체크)
+ * @param request 사용자 요청
+ * @returns 명확하면 true
+ */
+export declare function isRequestClear(request: string): boolean;

package/dist/tools/spec-system/clarity-checker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/spec-system/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Spec 시스템
+ * 비개발자를 위한 요청 명확화 및 스펙 문서 관리
+ */
+export type { SpecStatus, SpecMetadata, SpecFile, SpecScenario, ClarityResult, Ambiguity, AmbiguityCategory, SuggestedQuestion, SpecConfirmationChoice, SpecConfirmationResult, } from "./types";
+export { checkClarity, isRequestClear, generateClarityPrompt } from "./clarity-checker";
+export { getSpecsDir, generateSpecFilename, getSpecFilePath, createSpecFile, readSpecFile, markSpecAsCompleted, listSpecFiles, listActiveSpecs, } from "./spec-file-manager";
+export { inferCategory, buildScenarios, extractRequirements, buildSpec, generateSpecConfirmationMessage, parseUserChoice, } from "./scenario-builder";
+export type { ScenarioContext, FeatureCategory } from "./scenario-builder";

package/dist/tools/spec-system/scenario-builder.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 시나리오 빌더
+ * 사용자 요청과 Q&A를 바탕으로 시나리오 생성
+ */
+import type { SpecScenario, SpecFile } from "./types";
+/** 시나리오 생성 컨텍스트 */
+export interface ScenarioContext {
+    /** 원본 요청 */
+    originalRequest: string;
+    /** 질문-답변 목록 */
+    qna: Array<{
+        question: string;
+        answer: string;
+    }>;
+    /** 기능 카테고리 */
+    category?: FeatureCategory;
+}
+/** 기능 카테고리 */
+export type FeatureCategory = "ui-change" | "feature-add" | "bug-fix" | "refactor" | "content-update" | "style-change";
+/**
+ * 요청에서 기능 카테고리 추론
+ * @param request 사용자 요청
+ * @returns 추론된 카테고리
+ */
+export declare function inferCategory(request: string): FeatureCategory;
+/**
+ * 컨텍스트를 바탕으로 시나리오 생성
+ * @param context 시나리오 생성 컨텍스트
+ * @returns 생성된 시나리오 목록
+ */
+export declare function buildScenarios(context: ScenarioContext): SpecScenario[];
+/**
+ * 요구사항 추출
+ * @param context 컨텍스트
+ * @returns 요구사항 목록
+ */
+export declare function extractRequirements(context: ScenarioContext): string[];
+/**
+ * 전체 Spec 파일 데이터 생성
+ * @param context 컨텍스트
+ * @param title 기능명
+ * @returns Spec 파일 데이터
+ */
+export declare function buildSpec(context: ScenarioContext, title: string): Omit<SpecFile, "path" | "filename">;
+/**
+ * Spec 확인 메시지 생성
+ * @param specPath Spec 파일 경로
+ * @returns 사용자에게 보여줄 확인 메시지
+ */
+export declare function generateSpecConfirmationMessage(specPath: string): string;
+/**
+ * 사용자 응답을 선택 타입으로 파싱
+ * @param response 사용자 응답
+ * @returns 선택 타입 또는 null
+ */
+export declare function parseUserChoice(response: string): "proceed" | "modify" | "question" | null;

package/dist/tools/spec-system/spec-file-manager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Spec 파일 관리자
+ * md 파일 생성, 읽기, 수정, 파일명 변경 관리
+ */
+import type { SpecFile } from "./types";
+/**
+ * Spec 디렉토리 경로 가져오기
+ * @param projectRoot 프로젝트 루트 경로
+ * @returns Spec 디렉토리 절대 경로
+ */
+export declare function getSpecsDir(projectRoot: string): string;
+/**
+ * Spec 파일명 생성
+ * @param title 기능명
+ * @param isCompleted 완료 여부
+ * @returns 파일명 (확장자 포함)
+ */
+export declare function generateSpecFilename(title: string, isCompleted?: boolean): string;
+/**
+ * Spec 파일 경로 생성
+ * @param projectRoot 프로젝트 루트
+ * @param title 기능명
+ * @param isCompleted 완료 여부
+ * @returns 파일 절대 경로
+ */
+export declare function getSpecFilePath(projectRoot: string, title: string, isCompleted?: boolean): string;
+/**
+ * Spec 파일을 md 형식으로 생성
+ * @param projectRoot 프로젝트 루트
+ * @param spec Spec 데이터
+ * @returns 생성된 파일 경로
+ */
+export declare function createSpecFile(projectRoot: string, spec: Omit<SpecFile, "path" | "filename">): Promise<string>;
+/**
+ * Spec 파일 읽기
+ * @param filePath 파일 경로
+ * @returns Spec 객체
+ */
+export declare function readSpecFile(filePath: string): Promise<SpecFile>;
+/**
+ * Spec 파일을 완료 상태로 변경 (파일명 변경)
+ * @param projectRoot 프로젝트 루트
+ * @param currentPath 현재 파일 경로
+ * @returns 새 파일 경로
+ */
+export declare function markSpecAsCompleted(projectRoot: string, currentPath: string): Promise<string>;
+/**
+ * 모든 Spec 파일 목록 가져오기
+ * @param projectRoot 프로젝트 루트
+ * @param includeCompleted 완료된 것 포함 여부
+ * @returns Spec 파일 경로 목록
+ */
+export declare function listSpecFiles(projectRoot: string, includeCompleted?: boolean): Promise<string[]>;
+/**
+ * 진행 중인 Spec 파일만 가져오기
+ * @param projectRoot 프로젝트 루트
+ * @returns 진행 중인 Spec 파일 경로 목록
+ */
+export declare function listActiveSpecs(projectRoot: string): Promise<string[]>;

package/dist/tools/spec-system/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Spec 시스템 타입 정의
+ */
+/** Spec 파일 상태 */
+export type SpecStatus = "검토 중" | "확정" | "완료";
+/** Spec 파일 메타데이터 */
+export interface SpecMetadata {
+    /** 기능명 */
+    title: string;
+    /** 생성일 */
+    createdAt: Date;
+    /** 상태 */
+    status: SpecStatus;
+    /** 원본 요청 */
+    originalRequest: string;
+    /** 질문-답변 목록 */
+    qna?: Array<{
+        question: string;
+        answer: string;
+    }>;
+}
+/** Spec 파일 구조 */
+export interface SpecFile {
+    /** 파일 경로 */
+    path: string;
+    /** 파일명 */
+    filename: string;
+    /** 메타데이터 */
+    metadata: SpecMetadata;
+    /** 요구사항 목록 */
+    requirements: string[];
+    /** 시나리오 목록 */
+    scenarios: SpecScenario[];
+    /** 사용자 수정 요청 */
+    userModifications?: string[];
+    /** AI 메모 */
+    aiNotes?: string[];
+}
+/** 시나리오 */
+export interface SpecScenario {
+    /** 시나리오 이름 */
+    name: string;
+    /** 단계별 설명 */
+    steps: string[];
+    /** 기대 결과 */
+    expectedResult: string;
+}
+/** 명확성 판단 결과 */
+export interface ClarityResult {
+    /** 명확한지 여부 */
+    isClear: boolean;
+    /** 확신도 (0-100) */
+    confidence: number;
+    /** 불명확한 부분들 */
+    ambiguities: Ambiguity[];
+    /** 추천 질문들 */
+    suggestedQuestions: SuggestedQuestion[];
+}
+/** 불명확한 부분 */
+export interface Ambiguity {
+    /** 불명확한 내용 */
+    content: string;
+    /** 불명확한 이유 */
+    reason: string;
+    /** 카테고리 */
+    category: AmbiguityCategory;
+}
+/** 불명확 카테고리 */
+export type AmbiguityCategory = "target" | "behavior" | "value" | "scope" | "condition" | "priority";
+/** 추천 질문 */
+export interface SuggestedQuestion {
+    /** 질문 내용 */
+    question: string;
+    /** 선택지 (있는 경우) */
+    options?: string[];
+    /** 질문 카테고리 */
+    category: AmbiguityCategory;
+}
+/** Spec 확인 사용자 응답 */
+export type SpecConfirmationChoice = "1" | "2" | "3" | "proceed" | "modify" | "question";
+/** Spec 확인 결과 */
+export interface SpecConfirmationResult {
+    /** 선택한 옵션 */
+    choice: SpecConfirmationChoice;
+    /** 수정 내용 (2번 선택 시) */
+    modifications?: string;
+    /** 추가 질문 답변 (3번 선택 시) */
+    additionalAnswers?: Array<{
+        question: string;
+        answer: string;
+    }>;
+}

package/dist/tools/status-recorder/attempt-tracker.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 시도 추적 모듈
+ * 현재 세션 내 시도 기록 및 관리
+ */
+import type { Attempt, AttemptResult, StatusFile } from "./types";
+/**
+ * Status 디렉토리 경로 가져오기
+ * @param projectRoot 프로젝트 루트 경로
+ * @returns Status 디렉토리 절대 경로
+ */
+export declare function getStatusDir(projectRoot: string): string;
+/**
+ * Status 파일명 생성
+ * @param task 태스크 설명
+ * @param sessionId 세션 ID
+ * @returns 파일명 (확장자 포함)
+ */
+export declare function generateStatusFilename(task: string, sessionId: string): string;
+/**
+ * 새 Status 파일 생성
+ * @param projectRoot 프로젝트 루트
+ * @param task 태스크 설명
+ * @param sessionId 세션 ID
+ * @param specFile 관련 Spec 파일 (선택)
+ * @returns 생성된 Status 객체
+ */
+export declare function createStatus(projectRoot: string, task: string, sessionId: string, specFile?: string): Promise<StatusFile>;
+/**
+ * 시도 기록 추가
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @param method 시도한 방법
+ * @param result 결과
+ * @param reason 실패 이유 (선택)
+ * @param files 관련 파일들 (선택)
+ * @returns 업데이트된 Status
+ */
+export declare function recordAttempt(projectRoot: string, sessionId: string, method: string, result: AttemptResult, reason?: string, files?: string[]): Promise<StatusFile | null>;
+/**
+ * 교훈 추가
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @param lesson 배운 교훈
+ * @returns 업데이트된 Status
+ */
+export declare function addLesson(projectRoot: string, sessionId: string, lesson: string): Promise<StatusFile | null>;
+/**
+ * Status 완료 처리
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @param finalStatus 최종 상태
+ * @returns 업데이트된 Status
+ */
+export declare function completeStatus(projectRoot: string, sessionId: string, finalStatus?: "completed" | "failed" | "abandoned"): Promise<StatusFile | null>;
+/**
+ * 현재 세션의 Status 가져오기
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @returns Status 또는 null
+ */
+export declare function getStatus(projectRoot: string, sessionId: string): Promise<StatusFile | null>;
+/**
+ * 현재 세션의 실패 기록 가져오기
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @returns 실패한 시도 목록
+ */
+export declare function getFailedAttempts(projectRoot: string, sessionId: string): Promise<Attempt[]>;
+/**
+ * 특정 방법이 이미 실패했는지 확인
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @param method 확인할 방법
+ * @returns 실패 여부
+ */
+export declare function hasMethodFailed(projectRoot: string, sessionId: string, method: string): Promise<boolean>;
+/**
+ * 회피해야 할 방법들 가져오기
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @returns 회피할 방법과 이유 목록
+ */
+export declare function getAvoidMethods(projectRoot: string, sessionId: string): Promise<Array<{
+    method: string;
+    reason: string;
+}>>;
+/**
+ * 세션 캐시 클리어
+ * @param sessionId 클리어할 세션 ID (없으면 전체)
+ */
+export declare function clearSessionCache(sessionId?: string): void;
+/**
+ * AI 컨텍스트용 Status 요약 생성
+ * @param projectRoot 프로젝트 루트
+ * @param sessionId 세션 ID
+ * @returns AI에게 전달할 Status 요약
+ */
+export declare function generateStatusSummary(projectRoot: string, sessionId: string): Promise<string | null>;

package/dist/tools/status-recorder/failure-analyzer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 실패 분석 모듈
+ * 실패 패턴 감지 및 대안 제시
+ */
+import type { Attempt, FailureAnalysis, FailurePattern, LessonExtraction } from "./types";
+/**
+ * 실패 원인에서 패턴 감지
+ * @param reason 실패 이유
+ * @param errorMessage 에러 메시지 (선택)
+ * @returns 감지된 패턴
+ */
+export declare function detectFailurePattern(reason?: string, errorMessage?: string): FailurePattern;
+/**
+ * 실패 시도 분석
+ * @param attempt 실패한 시도
+ * @returns 분석 결과
+ */
+export declare function analyzeFailure(attempt: Attempt): FailureAnalysis;
+/**
+ * 여러 실패 시도 분석
+ * @param attempts 실패한 시도들
+ * @returns 종합 분석 결과
+ */
+export declare function analyzeMultipleFailures(attempts: Attempt[]): FailureAnalysis;
+/**
+ * 실패 패턴 설명 가져오기
+ * @param pattern 실패 패턴
+ * @returns 한국어 설명
+ */
+export declare function getPatternDescription(pattern: FailurePattern): string;
+/**
+ * 권장 대안 가져오기
+ * @param pattern 실패 패턴
+ * @returns 대안 목록
+ */
+export declare function getAlternatives(pattern: FailurePattern): string[];
+/**
+ * 여러 시도에서 교훈 추출
+ * @param attempts 시도 목록
+ * @returns 추출된 교훈들
+ */
+export declare function extractLessons(attempts: Attempt[]): LessonExtraction[];
+/**
+ * AI 컨텍스트용 실패 분석 요약 생성
+ * @param attempts 실패한 시도들
+ * @returns AI에게 전달할 분석 요약
+ */
+export declare function generateFailureAnalysisSummary(attempts: Attempt[]): string;

package/dist/tools/status-recorder/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Status 시스템
+ * 현재 세션 내 시도 기록 및 실패 분석
+ */
+export type { AttemptResult, Attempt, StatusFile, TaskStatus, FailureAnalysis, FailurePattern, StatusFilter, LessonExtraction, } from "./types";
+export { getStatusDir, generateStatusFilename, createStatus, recordAttempt, addLesson, completeStatus, getStatus, getFailedAttempts, hasMethodFailed, getAvoidMethods, clearSessionCache, generateStatusSummary, } from "./attempt-tracker";
+export { detectFailurePattern, analyzeFailure, analyzeMultipleFailures, getPatternDescription, getAlternatives, extractLessons, generateFailureAnalysisSummary, } from "./failure-analyzer";