@tomingtoming/kioq 0.7.0

package/dist/src/auditResponseSummary.js

@@ -0,0 +1,160 @@
+export function summarizeLintStructureResponse(args) {
+    if (args.unresolvedWikiLinkCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "unresolved_wikilinks_present",
+            nextRecommendedAction: "fix_unresolved_wikilinks",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.memoryContractViolationCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "memory_contract_violations_present",
+            nextRecommendedAction: "fix_memory_contract_violations",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.duplicateWarningCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "duplicate_warnings_present",
+            nextRecommendedAction: "review_duplicates",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.dependencyDirectionViolationCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "dependency_direction_violations_present",
+            nextRecommendedAction: "review_dependency_direction_violations",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.weakStructureCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "weak_structure_present",
+            nextRecommendedAction: "review_weak_structure_notes",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.orphanNoteCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "orphan_notes_present",
+            nextRecommendedAction: "review_orphan_notes",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.staleFlowCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "stale_flows_present",
+            nextRecommendedAction: "review_stale_flows",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.titleBodyMismatchCandidateCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "title_body_mismatch_candidates_present",
+            nextRecommendedAction: "review_title_body_mismatches",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    if (args.singleUseTagCandidateCount > 0) {
+        return {
+            primaryNavigationSignal: "audit_project_structure",
+            primaryQualitySignal: "single_use_tag_candidates_present",
+            nextRecommendedAction: "review_single_use_tags",
+            nextRecommendedTarget: args.firstIssueTitle,
+        };
+    }
+    return {
+        primaryNavigationSignal: "audit_project_structure",
+        primaryQualitySignal: "structure_health_ok",
+        nextRecommendedAction: "continue_work",
+    };
+}
+export function lintStructureResponsePlan(mode) {
+    if (mode === "minimal") {
+        return {
+            includeDebtBreakdown: false,
+            includeCompactIssues: false,
+            includeDetailedIssues: false,
+        };
+    }
+    if (mode === "standard") {
+        return {
+            includeDebtBreakdown: true,
+            includeCompactIssues: true,
+            includeDetailedIssues: false,
+        };
+    }
+    return {
+        includeDebtBreakdown: true,
+        includeCompactIssues: false,
+        includeDetailedIssues: true,
+    };
+}
+export function lintStructureResponseModeHint(args) {
+    const hasIssues = args.unresolvedWikiLinkCount > 0
+        || args.memoryContractViolationCount > 0
+        || args.duplicateWarningCount > 0
+        || args.dependencyDirectionViolationCount > 0
+        || args.weakStructureCount > 0
+        || args.orphanNoteCount > 0
+        || args.staleFlowCount > 0
+        || args.singleUseTagCandidateCount > 0
+        || args.titleBodyMismatchCandidateCount > 0;
+    if (args.mode === "minimal" && hasIssues) {
+        return {
+            recommendedResponseMode: "standard",
+            responseModeHint: "debt breakdown と top issues を見るには standard に上げる",
+        };
+    }
+    const needsDetailedIssueText = args.unresolvedWikiLinkCount > 0
+        || args.memoryContractViolationCount > 0
+        || args.duplicateWarningCount > 0
+        || args.dependencyDirectionViolationCount > 0
+        || args.weakStructureCount > 0
+        || args.orphanNoteCount > 0;
+    const onlySingleUseTagCandidates = args.singleUseTagCandidateCount > 0
+        && args.unresolvedWikiLinkCount === 0
+        && args.memoryContractViolationCount === 0
+        && args.duplicateWarningCount === 0
+        && args.dependencyDirectionViolationCount === 0
+        && args.weakStructureCount === 0
+        && args.orphanNoteCount === 0
+        && args.staleFlowCount === 0
+        && args.titleBodyMismatchCandidateCount === 0;
+    const onlyTitleBodyMismatchCandidates = args.titleBodyMismatchCandidateCount > 0
+        && args.unresolvedWikiLinkCount === 0
+        && args.memoryContractViolationCount === 0
+        && args.duplicateWarningCount === 0
+        && args.dependencyDirectionViolationCount === 0
+        && args.weakStructureCount === 0
+        && args.orphanNoteCount === 0
+        && args.staleFlowCount === 0
+        && args.singleUseTagCandidateCount === 0;
+    if (args.mode === "standard" && needsDetailedIssueText) {
+        return {
+            recommendedResponseMode: "verbose",
+            responseModeHint: "issue の message / suggestion を見るには verbose に上げる",
+        };
+    }
+    if (args.mode === "standard" && onlySingleUseTagCandidates) {
+        return {
+            recommendedResponseMode: "verbose",
+            responseModeHint: "単発使用 tag 候補の tag 名を確認するには verbose に上げる",
+        };
+    }
+    if (args.mode === "standard" && onlyTitleBodyMismatchCandidates) {
+        return {
+            recommendedResponseMode: "verbose",
+            responseModeHint: "title と本文のズレ理由を見るには verbose に上げる",
+        };
+    }
+    return {};
+}

package/dist/src/changeTriggerSummary.js

@@ -0,0 +1,116 @@
+export function summarizeReadChangeTrigger(args) {
+    if (args.unresolvedWikiLinkCount > 0) {
+        return {
+            code: "unresolved_wikilinks",
+            confidence: "high",
+            cascadeTargets: ["resolve_links", "repair_note_links"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.boundaryWarningCount > 0) {
+        return {
+            code: "responsibility_boundary",
+            confidence: "medium",
+            cascadeTargets: ["review_boundary_warnings", "rewrite_with_correct_tool"],
+            noiseRisk: "medium",
+        };
+    }
+    if (args.orphanWarning) {
+        return {
+            code: "orphan_note",
+            confidence: "medium",
+            cascadeTargets: args.indexCandidateAvailable
+                ? ["open_index_candidate", "add_backlinks"]
+                : ["add_backlinks", "review_note_context"],
+            noiseRisk: "medium",
+        };
+    }
+    if (args.clarityAttention) {
+        return {
+            code: "document_clarity",
+            confidence: "medium",
+            cascadeTargets: ["review_document_clarity", "rewrite_summary"],
+            noiseRisk: "medium",
+        };
+    }
+    return {
+        code: "none",
+    };
+}
+export function summarizeLintChangeTrigger(args) {
+    if (args.unresolvedWikiLinkCount > 0) {
+        return {
+            code: "unresolved_wikilinks",
+            confidence: "high",
+            cascadeTargets: ["resolve_links", "repair_note_structure"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.memoryContractViolationCount > 0) {
+        return {
+            code: "memory_contract_violation",
+            confidence: "high",
+            cascadeTargets: ["read_note", "repair_note_structure"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.duplicateWarningCount > 0) {
+        return {
+            code: "duplicate_conflict",
+            confidence: "medium",
+            cascadeTargets: ["review_duplicates", "rename_or_merge"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.dependencyDirectionViolationCount > 0) {
+        return {
+            code: "dependency_direction_violation",
+            confidence: "medium",
+            cascadeTargets: ["review_dependency_direction_violations", "move_links_to_related"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.weakStructureCount > 0) {
+        return {
+            code: "weak_structure",
+            confidence: "medium",
+            cascadeTargets: ["read_note", "add_links"],
+            noiseRisk: "medium",
+        };
+    }
+    if (args.orphanNoteCount > 0) {
+        return {
+            code: "orphan_note",
+            confidence: "medium",
+            cascadeTargets: ["review_orphan_repair_queue", "link_or_reparent_notes"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.staleFlowCount > 0) {
+        return {
+            code: "stale_flow",
+            confidence: "medium",
+            cascadeTargets: ["triage_flows", "update_flow_state"],
+            noiseRisk: "low",
+        };
+    }
+    if (args.titleBodyMismatchCandidateCount > 0) {
+        return {
+            code: "title_body_mismatch",
+            confidence: "low",
+            cascadeTargets: ["review_title_body_mismatches", "rewrite_note_summary"],
+            noiseRisk: "medium",
+        };
+    }
+    if (args.singleUseTagCandidateCount > 0) {
+        return {
+            code: "single_use_tag",
+            confidence: "low",
+            cascadeTargets: ["review_single_use_tags", "normalize_tags"],
+            noiseRisk: "medium",
+        };
+    }
+    return {
+        code: "none",
+    };
+}

package/dist/src/config.js

@@ -0,0 +1,192 @@
+import path from "node:path";
+import os from "node:os";
+function parsePreviewLength(value) {
+    const parsed = Number(value ?? "320");
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return 320;
+    }
+    return Math.floor(parsed);
+}
+function parseNonNegativeInteger(value, fallback) {
+    const parsed = Number(value ?? String(fallback));
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return fallback;
+    }
+    return Math.floor(parsed);
+}
+function parsePositiveInteger(value, fallback) {
+    const parsed = Number(value ?? String(fallback));
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        return fallback;
+    }
+    return Math.floor(parsed);
+}
+function readOptionValue(argv, index) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) {
+        return { nextIndex: index };
+    }
+    const equalIndex = arg.indexOf("=");
+    if (equalIndex >= 0) {
+        return {
+            value: arg.slice(equalIndex + 1),
+            nextIndex: index,
+        };
+    }
+    const nextValue = argv[index + 1];
+    if (nextValue && !nextValue.startsWith("--")) {
+        return {
+            value: nextValue,
+            nextIndex: index + 1,
+        };
+    }
+    return { nextIndex: index };
+}
+function matchesOption(arg, optionName) {
+    return arg === optionName || arg.startsWith(`${optionName}=`);
+}
+function parseDefaultDirectory(value) {
+    const candidate = value?.trim();
+    return candidate && candidate.length > 0 ? candidate : "Inbox";
+}
+function parseCliOptions(argv) {
+    const options = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg.startsWith("--")) {
+            continue;
+        }
+        if (matchesOption(arg, "--root")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.root = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--github-token")) {
+            throw new Error("--github-token has been removed; use KIOQ_GITHUB_TOKEN");
+        }
+        if (matchesOption(arg, "--github-token-file")) {
+            throw new Error("--github-token-file has been removed; use KIOQ_GITHUB_TOKEN");
+        }
+        if (matchesOption(arg, "--github-branch")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.githubBranch = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--github-repo")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.github = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--github")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.github = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--default-directory")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.defaultDirectory = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--preview-length")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.previewLength = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--index-score-threshold")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.indexScoreThreshold = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--index-section-threshold")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.indexSectionThreshold = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (matchesOption(arg, "--stale-flow-days")) {
+            const { value, nextIndex } = readOptionValue(argv, index);
+            if (value && value.trim().length > 0) {
+                options.staleFlowDays = value;
+            }
+            index = nextIndex;
+            continue;
+        }
+    }
+    return options;
+}
+function parseGitHubSlug(value) {
+    const slashIndex = value.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === value.length - 1) {
+        throw new Error(`Invalid GitHub slug "${value}": expected "owner/repo" format`);
+    }
+    return {
+        owner: value.slice(0, slashIndex),
+        repo: value.slice(slashIndex + 1),
+    };
+}
+export function loadConfig(env = process.env, argv = process.argv.slice(2)) {
+    const cli = parseCliOptions(argv);
+    if (env.KIOQ_GITHUB_TOKEN_FILE) {
+        throw new Error("KIOQ_GITHUB_TOKEN_FILE has been removed; use KIOQ_GITHUB_TOKEN");
+    }
+    const githubSlug = cli.github ?? env.KIOQ_GITHUB;
+    const isGitHubMode = !!githubSlug;
+    let github;
+    let root;
+    if (isGitHubMode) {
+        const { owner, repo } = parseGitHubSlug(githubSlug);
+        const token = env.KIOQ_GITHUB_TOKEN;
+        const branch = cli.githubBranch ?? env.KIOQ_GITHUB_BRANCH ?? "main";
+        if (!token) {
+            throw new Error("KIOQ_GITHUB_TOKEN is required when GitHub mode is enabled");
+        }
+        github = { owner, repo, branch, token };
+        const rawRoot = cli.root ?? env.KIOQ_ROOT;
+        root = rawRoot
+            ? path.resolve(rawRoot)
+            : path.join(os.homedir(), ".cache", "kioq", owner, repo);
+    }
+    else {
+        const rawRoot = cli.root ?? env.KIOQ_ROOT;
+        if (!rawRoot) {
+            throw new Error("KIOQ_ROOT or --root is required");
+        }
+        root = path.resolve(rawRoot);
+    }
+    return {
+        root,
+        defaultDirectory: parseDefaultDirectory(cli.defaultDirectory ?? env.KIOQ_DEFAULT_DIRECTORY),
+        github,
+        previewLength: parsePreviewLength(cli.previewLength ?? env.KIOQ_PREVIEW_LENGTH),
+        indexNavigation: {
+            scoreThreshold: parseNonNegativeInteger(cli.indexScoreThreshold ?? env.KIOQ_INDEX_SCORE_THRESHOLD, 70),
+            sectionThreshold: parsePositiveInteger(cli.indexSectionThreshold ?? env.KIOQ_INDEX_SECTION_THRESHOLD, 2),
+        },
+        technicalDebt: {
+            staleFlowDays: parsePositiveInteger(cli.staleFlowDays ?? env.KIOQ_STALE_FLOW_DAYS, 7),
+        },
+    };
+}

package/dist/src/conflictSummary.js

@@ -0,0 +1,7 @@
+export function summarizeNoConflict(args) {
+    return {
+        conflictType: "none",
+        serverUpdated: args.serverUpdated,
+        retryHint: "reread_before_retry_if_parallel_edits_possible",
+    };
+}

package/dist/src/contractResponseSummary.js

@@ -0,0 +1,43 @@
+export function summarizeMemoryContractResponse() {
+    return {
+        primaryNavigationSignal: "contract_available",
+        primaryQualitySignal: "contract_ready",
+        nextRecommendedAction: "follow_memory_contract",
+    };
+}
+export function memoryContractResponsePlan(mode) {
+    if (mode === "minimal") {
+        return {
+            includePolicyRules: false,
+            includePolicySignals: false,
+            includeSampleTemplates: false,
+        };
+    }
+    if (mode === "standard") {
+        return {
+            includePolicyRules: true,
+            includePolicySignals: false,
+            includeSampleTemplates: false,
+        };
+    }
+    return {
+        includePolicyRules: true,
+        includePolicySignals: true,
+        includeSampleTemplates: true,
+    };
+}
+export function memoryContractResponseModeHint(mode) {
+    if (mode === "minimal") {
+        return {
+            recommendedResponseMode: "standard",
+            responseModeHint: "policy と rules を見るには standard に上げる",
+        };
+    }
+    if (mode === "standard") {
+        return {
+            recommendedResponseMode: "verbose",
+            responseModeHint: "sample template 本文を見るには verbose に上げる",
+        };
+    }
+    return {};
+}