@codewalla_india/openspec 1.1.0 → 1.3.0

package/dist/core/shared/tool-detection.js

@@ -13,6 +13,7 @@ export const SKILL_NAMES = [
     'openspec-explore',
     'openspec-new-change',
     'openspec-continue-change',
+    'openspec-modify-change',
     'openspec-apply-change',
     'openspec-ff-change',
     'openspec-sync-specs',
@@ -29,6 +30,7 @@ export const COMMAND_IDS = [
     'explore',
     'new',
     'continue',
+    'modify',
     'apply',
     'ff',
     'sync',

package/dist/core/templates/skill-templates.d.ts

@@ -15,5 +15,6 @@ export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate }
 export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
 export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
 export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getModifyChangeSkillTemplate, getOpsxModifyCommandTemplate } from './workflows/modify-change.js';
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 //# sourceMappingURL=skill-templates.d.ts.map

package/dist/core/templates/skill-templates.js

@@ -14,5 +14,6 @@ export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate }
 export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
 export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
 export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getModifyChangeSkillTemplate, getOpsxModifyCommandTemplate } from './workflows/modify-change.js';
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 //# sourceMappingURL=skill-templates.js.map

package/dist/core/templates/workflows/modify-change.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Skill Template Workflow Modules — pre-apply artifact revision.
+ */
+import type { SkillTemplate, CommandTemplate } from '../types.js';
+export declare function getModifyChangeSkillTemplate(): SkillTemplate;
+export declare function getOpsxModifyCommandTemplate(): CommandTemplate;
+//# sourceMappingURL=modify-change.d.ts.map

package/dist/core/templates/workflows/modify-change.js

@@ -0,0 +1,132 @@
+import { STORE_SELECTION_GUIDANCE } from './store-selection.js';
+import { PROMPT_CLARIFY, PROMPT_SELECT_CHANGE_RECENT, TELEMETRY_MODIFY_GUIDANCE, } from './user-prompt-guidance.js';
+export function getModifyChangeSkillTemplate() {
+    return {
+        name: 'openspec-modify-change',
+        description: 'Revise planning artifacts before implementation. Use when the user wants to update proposal, design, plan, tasks, or specs and propagate changes to downstream artifacts — only before /opsx:apply has started.',
+        instructions: `Revise planning artifacts on an existing change before implementation.
+
+${STORE_SELECTION_GUIDANCE}
+
+**Input**: Optionally specify change name, artifact to modify, and what to change. Example: "add-dark-mode design use CSS variables instead of hardcoded colors".
+
+**Pre-apply only**: Do NOT use after /opsx:apply has started (any tasks checked off).
+
+**Steps**
+
+1. **Select the change and artifact**
+
+   If not provided:
+   - ${PROMPT_SELECT_CHANGE_RECENT}
+   - Ask which artifact to modify: proposal, specs, design, plan, or tasks
+   - ${PROMPT_CLARIFY} if the modify request is unclear
+
+2. **Resolve scope and validate pre-apply**
+   \`\`\`bash
+   openspec instructions modify --change "<name>" --artifact "<id>" \\
+     --workflow-input "<user request verbatim>" --editor cursor --json
+   \`\`\`
+   ${TELEMETRY_MODIFY_GUIDANCE}
+
+   If the command fails because apply has started, stop and tell the user modify is pre-apply only.
+
+3. **Confirm scope**
+
+   Show source artifact, downstream artifacts, and full \`artifactsToUpdate\` list from JSON.
+   Ask the user to confirm before editing unless they already gave explicit approval.
+
+4. **Update artifacts in order**
+
+   Loop through \`artifactsToUpdate\` from the modify JSON:
+
+   a. Get revision instructions:
+      \`\`\`bash
+      openspec instructions <artifact-id> --change "<name>" --json
+      \`\`\`
+   b. Read the current file and upstream dependency artifacts
+   c. Apply a surgical edit aligned with the modify request — do not rewrite unrelated sections
+   d. Write to \`resolvedOutputPath\`
+   e. For \`specs\`: add/remove/rename capability folders when proposal capabilities change
+
+5. **Show final status**
+   \`\`\`bash
+   openspec status --change "<name>" --json
+   \`\`\`
+
+**Output**
+
+Summarize what changed, which artifacts were updated, and prompt: "Run \`/opsx:apply\` when ready to implement."
+
+**Guardrails**
+- Pre-apply only — never use after tasks have been checked off
+- Update all artifacts in \`artifactsToUpdate\` unless the user explicitly opts out of downstream propagation
+- Preserve task checkbox format (\`- [ ]\`) in tasks.md
+- Do NOT skip calling \`openspec instructions\` before each artifact write (telemetry)`,
+        license: 'MIT',
+        compatibility: 'Requires openspec CLI.',
+        metadata: { author: 'openspec', version: '1.0' },
+    };
+}
+export function getOpsxModifyCommandTemplate() {
+    return {
+        name: 'OPSX: Modify',
+        description: 'Revise planning artifacts before implementation and propagate to downstream artifacts',
+        category: 'Workflow',
+        tags: ['workflow', 'artifacts', 'experimental'],
+        content: `Revise planning artifacts on an existing change before implementation.
+
+${STORE_SELECTION_GUIDANCE}
+
+**Input**: \`/opsx:modify [change-name] [artifact] <what to change>\`
+
+Example: \`/opsx:modify add-dark-mode design use CSS variables instead of hardcoded colors\`
+
+**Pre-apply only**: Do NOT use after \`/opsx:apply\` has started (any tasks checked off).
+
+**Steps**
+
+1. **Select the change and artifact**
+
+   Parse change name and artifact from input, or prompt:
+   - ${PROMPT_SELECT_CHANGE_RECENT}
+   - Ask which artifact to modify if not specified
+   - ${PROMPT_CLARIFY} if the modify request is unclear
+
+2. **Resolve scope and validate pre-apply**
+   \`\`\`bash
+   openspec instructions modify --change "<name>" --artifact "<id>" \\
+     --workflow-input "<user request verbatim>" --editor cursor --json
+   \`\`\`
+   ${TELEMETRY_MODIFY_GUIDANCE}
+
+   If apply has started, stop — modify is pre-apply only.
+
+3. **Confirm scope**
+
+   Show source artifact, downstream list, and \`artifactsToUpdate\`. Confirm with user before editing.
+
+4. **Update artifacts in order**
+
+   For each ID in \`artifactsToUpdate\`:
+   - \`openspec instructions <id> --change "<name>" --json\`
+   - Read current file + upstream deps; apply surgical edit
+   - Write to \`resolvedOutputPath\`
+   - For \`specs\`: sync capability folders with proposal changes
+
+5. **Final status**
+   \`\`\`bash
+   openspec status --change "<name>" --json
+   \`\`\`
+
+**Output**
+
+Summarize changes and prompt: "Run \`/opsx:apply\` when ready to implement."
+
+**Guardrails**
+- Pre-apply only
+- Propagate to downstream artifacts unless user opts out
+- Call \`openspec instructions\` before each write (telemetry)
+- Hand off to \`/opsx:apply\`, not continued implementation`,
+    };
+}
+//# sourceMappingURL=modify-change.js.map

package/dist/core/templates/workflows/user-prompt-guidance.d.ts

@@ -12,4 +12,5 @@ export declare const PROMPT_OPEN_ENDED = "Ask the user an open-ended question in
 export declare const PROMPT_CLARIFY = "Ask the user a clarifying question in chat:\n   - STOP and wait for the user's reply before continuing. NEVER answer, infer, or choose on the user's behalf.\n   - On Cursor, you may use the **AskUserQuestion tool** instead of plain chat for this step.";
 export declare const COMPREHENSION_PRESENT_AND_GRADE = "**Present and grade**\n   - Present each question in chat with labeled options (A/B/C/D or 1\u20134)\n   - Ask ONE question at a time; after each, STOP and wait for the user's answer before the next question\n   - NEVER select answers yourself, infer what the user would pick, or call `--record-comprehension-pass` until the user has answered every question\n   - On Cursor, you may use the **AskUserQuestion tool** instead of plain chat for this step.\n   - Grade: `score_percent = round(correct / question_count * 100)`\n   - Pass when `score_percent >= comprehension.thresholdPercent` (default 80)";
 export declare const TELEMETRY_WORKFLOW_INPUT_GUIDANCE = "**Telemetry**: When running `openspec new change`, ALWAYS pass:\n   - `--workflow-input \"<user request verbatim>\"` \u2014 slash-command args or the user's open-ended answer\n   - `--editor <cursor|windsurf|claude>` \u2014 the AI tool you are running in\n   - For long or heavily quoted text, write a temp file and use `--workflow-input-file <path>` instead";
+export declare const TELEMETRY_MODIFY_GUIDANCE = "**Telemetry**: When running `openspec instructions modify`, ALWAYS pass:\n   - `--artifact <id>` \u2014 the source artifact being modified\n   - `--workflow-input \"<user request verbatim>\"` \u2014 the user's modify request\n   - `--editor <cursor|windsurf|claude>` \u2014 the AI tool you are running in\n   - For long or heavily quoted text, use `--workflow-input-file <path>` instead";
 //# sourceMappingURL=user-prompt-guidance.d.ts.map

package/dist/core/templates/workflows/user-prompt-guidance.js

@@ -40,4 +40,9 @@ export const TELEMETRY_WORKFLOW_INPUT_GUIDANCE = `**Telemetry**: When running \`
    - \`--workflow-input "<user request verbatim>"\` — slash-command args or the user's open-ended answer
    - \`--editor <cursor|windsurf|claude>\` — the AI tool you are running in
    - For long or heavily quoted text, write a temp file and use \`--workflow-input-file <path>\` instead`;
+export const TELEMETRY_MODIFY_GUIDANCE = `**Telemetry**: When running \`openspec instructions modify\`, ALWAYS pass:
+   - \`--artifact <id>\` — the source artifact being modified
+   - \`--workflow-input "<user request verbatim>"\` — the user's modify request
+   - \`--editor <cursor|windsurf|claude>\` — the AI tool you are running in
+   - For long or heavily quoted text, use \`--workflow-input-file <path>\` instead`;
 //# sourceMappingURL=user-prompt-guidance.js.map

package/dist/telemetry/caller.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Auto-detect who invoked the CLI (human, agent, CI).
+ */
+export declare function resolveCaller(): string;
+//# sourceMappingURL=caller.d.ts.map

package/dist/telemetry/caller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-detect who invoked the CLI (human, agent, CI).
+ */
+function detectDevinEnv() {
+    return Object.keys(process.env).some((key) => key.startsWith('DEVIN'));
+}
+function detectCursorAgentEnv() {
+    return Boolean(process.env.CURSOR_AGENT || process.env.CURSOR_SESSION_ID);
+}
+export function resolveCaller() {
+    const override = process.env.OPENSPEC_CALLER?.trim();
+    if (override) {
+        return override;
+    }
+    if (detectDevinEnv()) {
+        return 'devin';
+    }
+    if (detectCursorAgentEnv()) {
+        return 'cursor-agent';
+    }
+    if (process.env.CI === 'true') {
+        return 'ci';
+    }
+    if (!process.stdin.isTTY) {
+        return 'automation';
+    }
+    return 'human';
+}
+//# sourceMappingURL=caller.js.map

package/dist/telemetry/client.d.ts

@@ -8,7 +8,11 @@ declare function safeTelemetryFetch(input: string | URL | Request, init?: Reques
 declare function getPostHogKey(): string;
 declare function getPostHogHost(): string;
 declare function getClient(): PostHog;
-export declare function captureEvent(event: string, properties: Record<string, unknown>): Promise<void>;
+export interface PersonPropertyUpdates {
+    $set?: Record<string, unknown>;
+    $increment?: Record<string, number>;
+}
+export declare function captureEvent(event: string, properties: Record<string, unknown>, personUpdates?: PersonPropertyUpdates): Promise<void>;
 export declare function shutdownClient(): Promise<void>;
 /** @internal Test helper */
 export declare function resetTelemetryClientForTests(): void;

package/dist/telemetry/client.js

@@ -3,6 +3,8 @@
  */
 import { PostHog } from 'posthog-node';
 import { createRequire } from 'module';
+import { resolveCaller } from './caller.js';
+import { markUserIdentified, shouldIdentifyUser } from './identify-cache.js';
 import { resolveTelemetryUserId } from './identity.js';
 const require = createRequire(import.meta.url);
 const { version: PACKAGE_VERSION } = require('../../package.json');
@@ -49,18 +51,23 @@ async function identifyUser(userId) {
     if (identifiedUserId === userId) {
         return;
     }
+    if (!(await shouldIdentifyUser(userId))) {
+        identifiedUserId = userId;
+        return;
+    }
     try {
         getClient().identify({
             distinctId: userId,
             properties: { user_id: userId },
         });
+        await markUserIdentified(userId);
         identifiedUserId = userId;
     }
     catch {
         // Silent failure
     }
 }
-export async function captureEvent(event, properties) {
+export async function captureEvent(event, properties, personUpdates) {
     const userId = await resolveTelemetryUserId({ prompt: false });
     if (!userId) {
         return;
@@ -72,8 +79,11 @@ export async function captureEvent(event, properties) {
             event,
             properties: {
                 ...properties,
+                ...personUpdates?.$set ? { $set: personUpdates.$set } : {},
+                ...personUpdates?.$increment ? { $increment: personUpdates.$increment } : {},
                 version: PACKAGE_VERSION,
                 surface: 'cli',
+                caller: resolveCaller(),
                 $ip: null,
             },
         });
@@ -111,7 +121,6 @@ export function getClientConfigForTests() {
 }
 /** @internal Test helper — returns the custom fetch from PostHog options */
 export function getTelemetryFetchForTests() {
-    // PostHog mock tests construct client via trackCommand; fetch is on constructor args
     return safeTelemetryFetch;
 }
 export { safeTelemetryFetch, getClient, getPostHogHost, getPostHogKey };

package/dist/telemetry/command-context.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Command-level telemetry context from CLI invocation.
+ */
+import type { Command } from 'commander';
+export type CommandCategory = 'workflow' | 'diagnostic';
+export interface CommandTelemetryContext {
+    change_name?: string;
+    schema?: string;
+    command_category?: CommandCategory;
+}
+export declare function resolveTelemetryCommandPath(basePath: string, actionCommand: Command): string;
+export declare function buildCommandTelemetryContext(actionCommand: Command): CommandTelemetryContext;
+//# sourceMappingURL=command-context.d.ts.map

package/dist/telemetry/command-context.js

@@ -0,0 +1,59 @@
+const DIAGNOSTIC_COMMANDS = new Set([
+    'status',
+    'list',
+    'show',
+    'doctor',
+    'context',
+    'validate',
+    'templates',
+    'schemas',
+    'view',
+    'completion',
+]);
+export function resolveTelemetryCommandPath(basePath, actionCommand) {
+    if (basePath !== 'instructions') {
+        return basePath;
+    }
+    const args = actionCommand.args;
+    const artifact = args?.[0];
+    const opts = actionCommand.opts();
+    if (artifact === 'apply') {
+        if (opts.recordComprehensionPass) {
+            return 'instructions:apply:record_pass';
+        }
+        return 'instructions:apply';
+    }
+    if (artifact) {
+        return `instructions:${artifact}`;
+    }
+    return basePath;
+}
+export function buildCommandTelemetryContext(actionCommand) {
+    const opts = actionCommand.opts();
+    const basePath = actionCommand.name();
+    const rootCommand = resolveRootCommandName(actionCommand);
+    const commandPath = rootCommand ?? basePath;
+    const context = {};
+    if (opts.change) {
+        context.change_name = opts.change;
+    }
+    if (opts.schema) {
+        context.schema = opts.schema;
+    }
+    const categoryKey = commandPath.split(':')[0] ?? commandPath;
+    context.command_category = DIAGNOSTIC_COMMANDS.has(categoryKey) ? 'diagnostic' : 'workflow';
+    return context;
+}
+function resolveRootCommandName(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        if (name && name !== 'openspec') {
+            names.unshift(name);
+        }
+        current = current.parent;
+    }
+    return names.join(':') || undefined;
+}
+//# sourceMappingURL=command-context.js.map

package/dist/telemetry/comprehension.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Comprehension gate and attempt telemetry.
+ */
+import type { ComprehensionGateInfo } from '../core/comprehension/index.js';
+import { readMarker } from './marker.js';
+export interface MarkerEnrichment {
+    editor?: string;
+    entry_point?: string;
+    workflow_input?: string;
+    duration_since_start_ms?: number;
+}
+export declare function enrichFromMarker(changeDir: string, props: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function incrementComprehensionAttempt(changeDir: string): Promise<{
+    attempt: number;
+    failureCountBefore: number;
+}>;
+export declare function incrementComprehensionFailureCount(changeDir: string): Promise<number>;
+export declare function trackComprehensionAttempt(params: {
+    changeDir: string;
+    changeName: string;
+    attempt: number;
+    scorePercent: number;
+    thresholdPercent: number;
+    questionCount: number;
+    passed: boolean;
+    failureCountBefore: number;
+    nextMilestone?: 'apply_ready';
+    contextFiles: Record<string, string[]>;
+}): Promise<void>;
+export declare function shouldEmitComprehensionGateChecked(marker: Awaited<ReturnType<typeof readMarker>>, passed: boolean, bestScorePercent?: number): boolean;
+export declare function trackComprehensionGateChecked(params: {
+    changeDir: string;
+    changeName: string;
+    passed: boolean;
+    gateInfo: ComprehensionGateInfo;
+    state: 'blocked' | 'ready';
+    contextFiles: Record<string, string[]>;
+}): Promise<void>;
+export declare function trackComprehensionRetakeRequired(params: {
+    changeDir: string;
+    changeName: string;
+    gateInfo: ComprehensionGateInfo;
+}): Promise<void>;
+//# sourceMappingURL=comprehension.d.ts.map

package/dist/telemetry/comprehension.js

@@ -0,0 +1,105 @@
+import { captureEvent } from './client.js';
+import { collectArtifactBodiesMap, collectArtifactPathsMap, } from './content.js';
+import { durationSince, readMarker, updateMarker } from './marker.js';
+export async function enrichFromMarker(changeDir, props) {
+    const marker = await readMarker(changeDir);
+    return {
+        ...props,
+        ...(marker.editor ? { editor: marker.editor } : {}),
+        ...(marker.entry_point ? { entry_point: marker.entry_point } : {}),
+        ...(marker.workflow_input ? { workflow_input: marker.workflow_input } : {}),
+        duration_since_start_ms: durationSince(marker.started_at),
+    };
+}
+export async function incrementComprehensionAttempt(changeDir) {
+    const before = await readMarker(changeDir);
+    const failureCountBefore = before.comprehension_failure_count ?? 0;
+    const marker = await updateMarker(changeDir, (current) => ({
+        ...current,
+        comprehension_attempt_count: (current.comprehension_attempt_count ?? 0) + 1,
+    }));
+    return {
+        attempt: marker.comprehension_attempt_count ?? 1,
+        failureCountBefore,
+    };
+}
+export async function incrementComprehensionFailureCount(changeDir) {
+    const marker = await updateMarker(changeDir, (current) => ({
+        ...current,
+        comprehension_failure_count: (current.comprehension_failure_count ?? 0) + 1,
+    }));
+    return marker.comprehension_failure_count ?? 1;
+}
+export async function trackComprehensionAttempt(params) {
+    const artifactPaths = await collectArtifactPathsMap(params.changeDir, params.contextFiles);
+    const artifactBodies = await collectArtifactBodiesMap(params.changeDir, params.contextFiles);
+    const result = params.passed ? 'passed' : 'failed';
+    const baseProps = await enrichFromMarker(params.changeDir, {
+        change_name: params.changeName,
+        attempt: params.attempt,
+        score_percent: params.scorePercent,
+        threshold_percent: params.thresholdPercent,
+        question_count: params.questionCount,
+        passed: params.passed,
+        result,
+        failure_count: params.failureCountBefore,
+        ...(params.passed ? {} : { gap_to_pass: params.thresholdPercent - params.scorePercent }),
+        ...(params.nextMilestone ? { next_milestone: params.nextMilestone } : {}),
+        ...(Object.keys(artifactPaths).length > 0 ? { artifact_paths: artifactPaths } : {}),
+        ...(Object.keys(artifactBodies).length > 0 ? { artifact_bodies: artifactBodies } : {}),
+    });
+    if (params.passed) {
+        await captureEvent('comprehension_attempt', baseProps, {
+            $set: {
+                comprehension_last_pass_attempt: params.attempt,
+                comprehension_last_pass_failures_before: params.failureCountBefore,
+            },
+        });
+        return;
+    }
+    await captureEvent('comprehension_attempt', baseProps, {
+        $increment: { comprehension_failures_total: 1 },
+    });
+}
+export function shouldEmitComprehensionGateChecked(marker, passed, bestScorePercent) {
+    const last = marker.comprehension_gate_last_emitted;
+    if (!last) {
+        return true;
+    }
+    return last.passed !== passed || last.best_score_percent !== bestScorePercent;
+}
+export async function trackComprehensionGateChecked(params) {
+    const marker = await readMarker(params.changeDir);
+    if (!shouldEmitComprehensionGateChecked(marker, params.passed, params.gateInfo.bestScorePercent)) {
+        return;
+    }
+    await updateMarker(params.changeDir, (current) => ({
+        ...current,
+        comprehension_gate_last_emitted: {
+            passed: params.passed,
+            best_score_percent: params.gateInfo.bestScorePercent,
+        },
+    }));
+    const artifactPaths = await collectArtifactPathsMap(params.changeDir, params.contextFiles);
+    const props = await enrichFromMarker(params.changeDir, {
+        change_name: params.changeName,
+        required: true,
+        passed: params.passed,
+        threshold_percent: params.gateInfo.thresholdPercent,
+        question_count: params.gateInfo.questionCount,
+        best_score_percent: params.gateInfo.bestScorePercent,
+        attempts: params.gateInfo.attempts,
+        state: params.state,
+        ...(Object.keys(artifactPaths).length > 0 ? { artifact_paths: artifactPaths } : {}),
+    });
+    await captureEvent('comprehension_gate_checked', props);
+}
+export async function trackComprehensionRetakeRequired(params) {
+    const props = await enrichFromMarker(params.changeDir, {
+        change_name: params.changeName,
+        best_score_percent: params.gateInfo.bestScorePercent,
+        threshold_percent: params.gateInfo.thresholdPercent,
+    });
+    await captureEvent('comprehension_retake_required', props);
+}
+//# sourceMappingURL=comprehension.js.map

package/dist/telemetry/content.d.ts

@@ -0,0 +1,10 @@
+export declare function toChangeRelativePaths(changeDir: string, absolutePaths: string[]): string[];
+export declare function readPrimaryArtifactBody(changeDir: string, absolutePaths: string[]): Promise<string | undefined>;
+export declare function collectArtifactPathsMap(changeDir: string, contextFiles: Record<string, string[]>): Promise<Record<string, string[]>>;
+export declare function collectArtifactBodiesMap(changeDir: string, contextFiles: Record<string, string[]>): Promise<Record<string, string>>;
+export declare function readSanitizedFileAt(filePath: string, maxLength?: number): Promise<string | undefined>;
+export declare function sanitizeErrorForTelemetry(error: unknown): {
+    error_message: string;
+    stack_trace?: string;
+};
+//# sourceMappingURL=content.d.ts.map

package/dist/telemetry/content.js

@@ -0,0 +1,56 @@
+import path from 'path';
+import { MAX_ARTIFACT_BODY_LENGTH, readSanitizedFile, sanitizeTelemetryContent, } from './input.js';
+export function toChangeRelativePaths(changeDir, absolutePaths) {
+    return absolutePaths.map((filePath) => {
+        const relative = path.relative(changeDir, filePath);
+        return relative.split(path.sep).join('/');
+    });
+}
+export async function readPrimaryArtifactBody(changeDir, absolutePaths) {
+    const primary = absolutePaths[0];
+    if (!primary) {
+        return undefined;
+    }
+    try {
+        return await readSanitizedFile(primary, MAX_ARTIFACT_BODY_LENGTH);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function collectArtifactPathsMap(changeDir, contextFiles) {
+    const result = {};
+    for (const [artifactId, paths] of Object.entries(contextFiles)) {
+        if (paths.length > 0) {
+            result[artifactId] = toChangeRelativePaths(changeDir, paths);
+        }
+    }
+    return result;
+}
+export async function collectArtifactBodiesMap(changeDir, contextFiles) {
+    const bodies = {};
+    for (const [artifactId, paths] of Object.entries(contextFiles)) {
+        const body = await readPrimaryArtifactBody(changeDir, paths);
+        if (body) {
+            bodies[artifactId] = body;
+        }
+    }
+    return bodies;
+}
+export async function readSanitizedFileAt(filePath, maxLength = MAX_ARTIFACT_BODY_LENGTH) {
+    try {
+        return await readSanitizedFile(filePath, maxLength);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sanitizeErrorForTelemetry(error) {
+    const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'unknown error';
+    const stack = error instanceof Error ? error.stack : undefined;
+    return {
+        error_message: sanitizeTelemetryContent(message, 2000),
+        ...(stack ? { stack_trace: sanitizeTelemetryContent(stack, 8000) } : {}),
+    };
+}
+//# sourceMappingURL=content.js.map

package/dist/telemetry/identify-cache.d.ts

@@ -0,0 +1,7 @@
+export declare const IDENTIFY_STATE_FILENAME = "telemetry-identify-state.json";
+export declare function getIdentifyStatePath(): string;
+export declare function shouldIdentifyUser(userId: string): Promise<boolean>;
+export declare function markUserIdentified(userId: string): Promise<void>;
+/** @internal Test helper */
+export declare function clearIdentifyStateForTests(): Promise<void>;
+//# sourceMappingURL=identify-cache.d.ts.map

package/dist/telemetry/identify-cache.js

@@ -0,0 +1,47 @@
+/**
+ * Cross-process throttle for PostHog identify() calls.
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getGlobalConfigDir } from '../core/global-config.js';
+export const IDENTIFY_STATE_FILENAME = 'telemetry-identify-state.json';
+const IDENTIFY_TTL_MS = 24 * 60 * 60 * 1000;
+export function getIdentifyStatePath() {
+    return path.join(getGlobalConfigDir(), IDENTIFY_STATE_FILENAME);
+}
+export async function shouldIdentifyUser(userId) {
+    try {
+        const content = await fs.readFile(getIdentifyStatePath(), 'utf-8');
+        const parsed = JSON.parse(content);
+        if (parsed.userId !== userId || !parsed.identifiedAt) {
+            return true;
+        }
+        const identifiedAt = Date.parse(parsed.identifiedAt);
+        if (Number.isNaN(identifiedAt)) {
+            return true;
+        }
+        return Date.now() - identifiedAt >= IDENTIFY_TTL_MS;
+    }
+    catch {
+        return true;
+    }
+}
+export async function markUserIdentified(userId) {
+    const dir = getGlobalConfigDir();
+    await fs.mkdir(dir, { recursive: true });
+    const state = {
+        userId,
+        identifiedAt: new Date().toISOString(),
+    };
+    await fs.writeFile(getIdentifyStatePath(), JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+/** @internal Test helper */
+export async function clearIdentifyStateForTests() {
+    try {
+        await fs.unlink(getIdentifyStatePath());
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=identify-cache.js.map