@codewalla_india/openspec 1.3.1 → 1.3.2

package/dist/commands/doctor.js

@@ -6,7 +6,7 @@
 import { Option } from 'commander';
 import { resolveRootForCommand, } from '../core/root-selection.js';
 import { readOptionalStoreMetadataState } from '../core/store/foundation.js';
-import { gitOriginUrl, isGitRepositoryAtRoot } from '../core/store/git.js';
+import { gitOriginUrl, gitTrackingDrift, isGitRepositoryAtRoot } from '../core/store/git.js';
 import { classifyOpenSpecDir, readProjectConfig, resolveConfigFilePath, } from '../core/project-config.js';
 import { findRepoPlanningRootSync } from '../core/planning-home.js';
 import { gatherRelationshipData } from './shared-gather.js';
@@ -27,7 +27,8 @@ async function gatherHealth(root) {
         referenceEntries,
         registryUnreadable,
     };
-    // Store facts for store-backed roots (explicit --store or declared).
+    // Store facts for store-backed roots (explicit --store, a declared
+    // pointer, or the global default).
     // Missing/invalid metadata never reaches here: store resolution
     // verifies identity first and fails with the existing taxonomy
     // (recorded amendment - corrupt store.yaml is an exit-1 resolution
@@ -35,14 +36,18 @@ async function gatherHealth(root) {
     if (root.storeId) {
         const metadata = await readOptionalStoreMetadataState(root.path).catch(() => null);
         // git -C walks UP the tree: probing a non-repo store nested inside
-        // another repo would record the ENCLOSING repo's origin.
-        const originUrl = (await isGitRepositoryAtRoot(root.path)) ? await gitOriginUrl(root.path) : null;
+        // another repo would record the ENCLOSING repo's origin (and drift).
+        const isRepo = await isGitRepositoryAtRoot(root.path);
+        const [originUrl, drift] = isRepo
+            ? await Promise.all([gitOriginUrl(root.path), gitTrackingDrift(root.path)])
+            : [null, null];
         input.storeFacts = {
             id: root.storeId,
             metadataPresent: metadata !== null,
             metadataValid: metadata !== null,
             ...(metadata?.remote ? { canonicalRemote: metadata.remote } : {}),
             ...(originUrl ? { originUrl } : {}),
+            ...(drift ? { drift } : {}),
         };
     }
     // The 3.2 both-shapes wrong turn, structured — including a malformed

package/dist/commands/feedback.js

@@ -1,7 +1,6 @@
 import { execSync, execFileSync } from 'child_process';
 import { createRequire } from 'module';
 import os from 'os';
-import { trackEvent } from '../telemetry/index.js';
 const require = createRequire(import.meta.url);
 /**
  * Check if gh CLI is installed and available in PATH
@@ -60,10 +59,10 @@ function generateMetadata() {
     const version = getVersion();
     const platform = getPlatform();
     const timestamp = getTimestamp();
-    return `---
-Submitted via OpenSpec CLI
-- Version: ${version}
-- Platform: ${platform}
+    return `---
+Submitted via OpenSpec CLI
+- Version: ${version}
+- Platform: ${platform}
 - Timestamp: ${timestamp}`;
 }
 /**
@@ -88,7 +87,7 @@ function formatBody(bodyText) {
  * Generate a pre-filled GitHub issue URL for manual submission
  */
 function generateManualSubmissionUrl(title, body) {
-    const repo = 'codewalla-engineering/OpenSpec';
+    const repo = 'codewalla-engineering/openspec-upstream-sync';
     const encodedTitle = encodeURIComponent(title);
     const encodedBody = encodeURIComponent(body);
     const encodedLabels = encodeURIComponent('feedback');
@@ -106,38 +105,88 @@ function displayFormattedFeedback(title, body) {
     console.log('--- END FEEDBACK ---\n');
 }
 /**
- * Submit feedback via gh CLI
+ * Check whether gh refused the issue because the repository does not define
+ * the label. gh resolves label names before creating the issue, so this
+ * failure means no issue was created.
+ *
+ * Only gh's stderr is inspected. The error message also embeds the command
+ * line, which carries the user's own feedback text.
+ */
+function isMissingLabelError(error) {
+    return /could not add label/i.test(error?.stderr?.toString() ?? '');
+}
+/**
+ * Report a gh CLI failure and exit, preserving gh's exit code.
+ *
+ * gh failed after the user already typed their feedback (issues disabled,
+ * network, rate limit, ...), so show the same manual-submission path the
+ * missing-gh and unauthenticated flows get instead of discarding the text.
+ */
+function reportGhFailure(error, title, body) {
+    // Display the error output from gh CLI
+    if (error.stderr) {
+        console.error(error.stderr.toString());
+    }
+    else if (error.message) {
+        console.error(error.message);
+    }
+    displayFormattedFeedback(title, body);
+    const manualUrl = generateManualSubmissionUrl(title, body);
+    console.log('Please submit your feedback manually:');
+    console.log(manualUrl);
+    // Exit with the same code as gh CLI
+    process.exit(error.status ?? 1);
+}
+/**
+ * Create the feedback issue via gh CLI
  * Uses execFileSync to prevent shell injection vulnerabilities
  */
+function createIssue(title, body, labels) {
+    const args = [
+        'issue',
+        'create',
+        '--repo',
+        'codewalla-engineering/openspec-upstream-sync',
+        '--title',
+        title,
+        '--body',
+        body,
+    ];
+    for (const label of labels) {
+        args.push('--label', label);
+    }
+    const result = execFileSync('gh', args, { encoding: 'utf-8', stdio: 'pipe' });
+    return result.trim();
+}
+/**
+ * Submit feedback via gh CLI
+ */
 function submitViaGhCli(title, body) {
+    let issueUrl;
+    let labelApplied = true;
     try {
-        const result = execFileSync('gh', [
-            'issue',
-            'create',
-            '--repo',
-            'codewalla-engineering/OpenSpec',
-            '--title',
-            title,
-            '--body',
-            body,
-            '--label',
-            'feedback',
-        ], { encoding: 'utf-8', stdio: 'pipe' });
-        const issueUrl = result.trim();
-        trackEvent('feedback_submitted', { has_body: Boolean(body) });
-        console.log(`\n✓ Feedback submitted successfully!`);
-        console.log(`Issue URL: ${issueUrl}\n`);
+        issueUrl = createIssue(title, body, ['feedback']);
     }
     catch (error) {
-        // Display the error output from gh CLI
-        if (error.stderr) {
-            console.error(error.stderr.toString());
+        if (!isMissingLabelError(error)) {
+            reportGhFailure(error, title, body);
+            return;
         }
-        else if (error.message) {
-            console.error(error.message);
+        // The repository does not define the 'feedback' label. Nothing was
+        // created, so retry unlabeled rather than dropping the feedback.
+        try {
+            issueUrl = createIssue(title, body, []);
+            labelApplied = false;
         }
-        // Exit with the same code as gh CLI
-        process.exit(error.status ?? 1);
+        catch (retryError) {
+            reportGhFailure(retryError, title, body);
+            return;
+        }
+    }
+    console.log(`\n✓ Feedback submitted successfully!`);
+    console.log(`Issue URL: ${issueUrl}\n`);
+    if (!labelApplied) {
+        console.log("Note: created without the 'feedback' label because the repository does not define it.\n");
     }
 }
 /**

package/dist/commands/modify.d.ts

@@ -0,0 +1,26 @@
+import { Command } from 'commander';
+export interface ModifyCommandOptions {
+    artifact: string;
+    workflowInput?: string;
+    editor?: boolean;
+    change: string;
+    json?: boolean;
+}
+export interface ModifyCommandOutput {
+    success: boolean;
+    artifactsToUpdate: Array<{
+        artifactId: string;
+        filePath: string;
+        modificationScope: 'direct' | 'propagated';
+    }>;
+    conflicts?: Array<{
+        artifactId: string;
+        affectedSections: string[];
+    }>;
+    reason?: string;
+}
+/**
+ * Creates the modify command.
+ */
+export declare function createModifyCommand(): Command;
+//# sourceMappingURL=modify.d.ts.map

package/dist/commands/modify.js

@@ -0,0 +1,147 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { ArtifactGraph } from '../core/artifact-graph/graph.js';
+import { canModify } from '../core/change-status-policy.js';
+import { DependencyPropagator } from '../core/modify/dependency-propagator.js';
+import { ConflictDetector } from '../core/modify/conflict-detector.js';
+import { HistoryTracker } from '../core/modify/history-tracker.js';
+import { resolveCurrentPlanningHomeSync } from '../core/planning-home.js';
+import { resolveArtifactOutputPath } from '../core/artifact-graph/outputs.js';
+import { trackArtifactModifyRequested, trackArtifactRevisionRequested, trackChangeProposalReady } from '../telemetry/index.js';
+/**
+ * Creates the modify command.
+ */
+export function createModifyCommand() {
+    const command = new Command('modify')
+        .description('Modify planning artifacts before implementation starts')
+        .option('--artifact <id>', 'Artifact ID to modify')
+        .option('--workflow-input <path>', 'Workflow input file')
+        .option('--editor', 'Open in editor after modification')
+        .option('--json', 'Output JSON')
+        .argument('[change]', 'Change name')
+        .action(async (changeName, options) => {
+        const modifyOptions = {
+            artifact: options.artifact,
+            workflowInput: options.workflowInput,
+            editor: options.editor,
+            change: changeName,
+            json: options.json,
+        };
+        try {
+            const result = await executeModify(modifyOptions);
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(formatOutput(result));
+            }
+        }
+        catch (error) {
+            const errorOutput = {
+                success: false,
+                artifactsToUpdate: [],
+                reason: error instanceof Error ? error.message : String(error),
+            };
+            if (options.json) {
+                console.log(JSON.stringify(errorOutput, null, 2));
+            }
+            else {
+                console.error(`Error: ${errorOutput.reason}`);
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}
+/**
+ * Executes the modify command logic.
+ */
+async function executeModify(options) {
+    const planningHome = resolveCurrentPlanningHomeSync();
+    const changesDir = planningHome.changesDir;
+    const changeRoot = planningHome.root;
+    // Pre-apply validation: check if implementation has started
+    const canModifyResult = await canModify(options.change, changesDir);
+    if (!canModifyResult.canModify) {
+        return {
+            success: false,
+            artifactsToUpdate: [],
+            reason: canModifyResult.reason,
+        };
+    }
+    // Load artifact graph
+    const schemaPath = planningHome.defaultSchema;
+    const graph = ArtifactGraph.fromYaml(schemaPath);
+    // Get artifact to modify
+    const artifactId = options.artifact;
+    if (!artifactId) {
+        throw new Error('--artifact flag is required');
+    }
+    const artifact = graph.getArtifact(artifactId);
+    if (!artifact) {
+        throw new Error(`Artifact not found: ${artifactId}`);
+    }
+    // Calculate update scope
+    const propagator = new DependencyPropagator(graph, changeRoot);
+    const updateScope = propagator.calculateUpdateScope([artifactId]);
+    // Build artifact paths map
+    const artifactPaths = new Map();
+    for (const id of updateScope) {
+        const art = graph.getArtifact(id);
+        if (art) {
+            const changeDir = join(changesDir, options.change);
+            const path = resolveArtifactOutputPath(changeDir, art.generates);
+            artifactPaths.set(id, path);
+        }
+    }
+    // Check for conflicts
+    const conflictDetector = new ConflictDetector(changeRoot);
+    const conflicts = await conflictDetector.detectAllConflicts(artifactPaths, new Map());
+    if (conflicts.length > 0) {
+        return {
+            success: false,
+            artifactsToUpdate: [],
+            conflicts,
+            reason: 'Conflicts detected with manual edits. Resolve conflicts before modifying.',
+        };
+    }
+    // Record modification history
+    const historyTracker = new HistoryTracker(changeRoot);
+    await historyTracker.recordModification(options.change, [artifactId], options.workflowInput || 'Manual modification');
+    // Emit telemetry events
+    await trackArtifactModifyRequested(options.change, artifactId);
+    // Track proposal ready if proposal artifact is being modified
+    if (artifactId === 'proposal') {
+        await trackChangeProposalReady(options.change);
+    }
+    for (const id of updateScope) {
+        if (id !== artifactId) {
+            await trackArtifactRevisionRequested(options.change, id);
+        }
+    }
+    // Build result
+    const artifactsToUpdate = updateScope.map((id) => ({
+        artifactId: id,
+        filePath: artifactPaths.get(id) || '',
+        modificationScope: id === artifactId ? 'direct' : 'propagated',
+    }));
+    return {
+        success: true,
+        artifactsToUpdate,
+    };
+}
+/**
+ * Formats the command output for human-readable display.
+ */
+function formatOutput(result) {
+    if (!result.success) {
+        return `Modification failed: ${result.reason}`;
+    }
+    let output = `Modification successful. ${result.artifactsToUpdate.length} artifacts to update:\n\n`;
+    for (const artifact of result.artifactsToUpdate) {
+        const scope = artifact.modificationScope === 'direct' ? 'direct' : 'propagated';
+        output += `  - ${artifact.artifactId} (${scope}): ${artifact.filePath}\n`;
+    }
+    return output;
+}
+//# sourceMappingURL=modify.js.map