shift-ax 0.3.0

package/dist/scripts/ax-init-context.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { writeContextBundle } from '../core/context/context-bundle.js';
+function usage() {
+    process.stderr.write('Usage: ax-init-context [--root DIR] [--topic DIR] --query "<text>" [--max-chars N] [--output PATH]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root');
+const topicDir = readArg('--topic');
+const query = readArg('--query');
+const outputPath = readArg('--output');
+const workflowStep = readArg('--workflow-step') || 'general';
+const maxChars = Number(readArg('--max-chars') || '6000');
+if (!query || (!rootDir && !topicDir)) {
+    usage();
+    process.exit(1);
+}
+const result = await writeContextBundle({
+    ...(rootDir ? { rootDir } : {}),
+    ...(topicDir ? { topicDir } : {}),
+    query,
+    ...(outputPath ? { outputPath } : {}),
+    workflowStep,
+    maxChars: Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 6000,
+});
+process.stdout.write(`${JSON.stringify({
+    query: result.bundle.query,
+    workflow_step: workflowStep,
+    status: result.status,
+    issues_count: result.bundle.issues.length,
+    max_chars: result.bundle.max_chars,
+    sections: result.bundle.sections.map((section) => ({
+        kind: section.kind,
+        item_count: section.items.length,
+    })),
+    output_path: result.output_path,
+}, null, 2)}\n`);

package/dist/scripts/ax-launch-execution.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { getPlatformAdapter } from '../adapters/index.js';
+function usage() {
+    process.stderr.write('Usage: ax-launch-execution --platform <codex|claude-code> --topic DIR [--task-id ID] [--dry-run]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const platform = readArg('--platform');
+const topicDir = readArg('--topic');
+const taskId = readArg('--task-id');
+const dryRun = process.argv.includes('--dry-run');
+if ((platform !== 'codex' && platform !== 'claude-code') || !topicDir) {
+    usage();
+    process.exit(1);
+}
+const adapter = getPlatformAdapter(platform);
+const result = dryRun
+    ? await adapter.planExecution({ topicDir, taskId })
+    : await adapter.launchExecution({ topicDir, taskId });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-learned-debug-save.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { recordLearnedDebugNote } from '../core/memory/learned-debug.js';
+function usage() {
+    process.stderr.write('Usage: ax-learned-debug-save --root DIR --summary "<text>" --resolution "<text>" [--occurrences N] [--approved] [--fix-commit SHA]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const summary = readArg('--summary');
+const resolution = readArg('--resolution');
+const occurrences = Number(readArg('--occurrences') || '1');
+const approved = process.argv.includes('--approved');
+const fixCommit = readArg('--fix-commit');
+if (!summary || !resolution) {
+    usage();
+    process.exit(1);
+}
+const result = await recordLearnedDebugNote({
+    rootDir,
+    summary,
+    resolution,
+    occurrences: Number.isFinite(occurrences) ? occurrences : 1,
+    approved,
+    ...(fixCommit ? { fixCommit } : {}),
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-learned-debug.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { listLearnedDebugNotes } from '../core/memory/learned-debug.js';
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const query = readArg('--query');
+const result = await listLearnedDebugNotes({ rootDir, ...(query ? { query } : {}) });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-monitor-context.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { writeContextMonitorSnapshot } from '../core/observability/context-monitor.js';
+function usage() {
+    process.stderr.write('Usage: ax-monitor-context [--root DIR] [--topic DIR] --query "<text>" [--max-chars N] [--output PATH]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root');
+const topicDir = readArg('--topic');
+const query = readArg('--query');
+const outputPath = readArg('--output');
+const maxChars = Number(readArg('--max-chars') || '6000');
+if (!query || (!rootDir && !topicDir)) {
+    usage();
+    process.exit(1);
+}
+const result = await writeContextMonitorSnapshot({
+    ...(rootDir ? { rootDir } : {}),
+    ...(topicDir ? { topicDir } : {}),
+    query,
+    ...(outputPath ? { outputPath } : {}),
+    maxChars: Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 6000,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-onboard-context.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stderr } from 'node:process';
+import { onboardProjectContext, onboardProjectContextFromDiscovery, } from '../core/context/onboarding.js';
+import { runGuidedOnboarding } from '../core/context/guided-onboarding.js';
+import { readProjectSettings, writeProjectSettings } from '../core/settings/project-settings.js';
+function usage() {
+    process.stderr.write('Usage: ax-onboard-context [--input FILE] [--discover] [--no-glossary] [--overwrite] [--lang en|ko] [--platform codex|claude-code] [--root DIR]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+async function createPromptSession() {
+    const fallbackAnswers = !stdin.isTTY
+        ? (await new Promise((resolve, reject) => {
+            let raw = '';
+            stdin.setEncoding('utf8');
+            stdin.on('data', (chunk) => {
+                raw += chunk;
+            });
+            stdin.on('end', () => resolve(raw));
+            stdin.on('error', reject);
+        }))
+            .split(/\r?\n/)
+        : null;
+    let fallbackIndex = 0;
+    const rl = stdin.isTTY
+        ? createInterface({
+            input: stdin,
+            output: stderr,
+        })
+        : null;
+    return {
+        ask: async (question) => {
+            if (rl) {
+                return rl.question(question);
+            }
+            stderr.write(question);
+            const answer = fallbackAnswers?.[fallbackIndex] ?? '';
+            fallbackIndex += 1;
+            return answer;
+        },
+        close: () => rl?.close(),
+    };
+}
+async function promptLocaleSelection(ask) {
+    const answer = (await ask('Choose language / 언어를 선택하세요:\n1. English (default)\n2. Korean\n> '))
+        .trim()
+        .toLowerCase();
+    return answer === '2' ? 'ko' : 'en';
+}
+async function main() {
+    const inputPath = readArg('--input');
+    const rootDir = readArg('--root') || process.cwd();
+    const discover = process.argv.includes('--discover');
+    const includeGlossary = !process.argv.includes('--no-glossary');
+    const overwrite = process.argv.includes('--overwrite');
+    const localeArg = readArg('--lang');
+    const platformArg = readArg('--platform');
+    const prompts = inputPath || discover || localeArg
+        ? null
+        : await createPromptSession();
+    const locale = localeArg === 'ko' || localeArg === 'en'
+        ? localeArg
+        : inputPath || discover
+            ? 'en'
+            : await promptLocaleSelection(prompts.ask);
+    try {
+        const result = inputPath
+            ? await onboardProjectContext({
+                ...JSON.parse(await readFile(inputPath, 'utf8')),
+                rootDir,
+                overwrite,
+            })
+            : discover
+                ? await onboardProjectContextFromDiscovery({ rootDir, includeGlossary, overwrite })
+                : await runGuidedOnboarding({
+                    rootDir,
+                    locale,
+                    ask: prompts.ask,
+                });
+        if (platformArg === 'codex' || platformArg === 'claude-code' || localeArg === 'en' || localeArg === 'ko') {
+            const existing = await readProjectSettings(rootDir);
+            await writeProjectSettings({
+                rootDir,
+                settings: {
+                    ...(existing ?? {}),
+                    version: 1,
+                    updated_at: new Date().toISOString(),
+                    locale: localeArg === 'en' || localeArg === 'ko' ? localeArg : existing?.locale ?? locale,
+                    ...(platformArg === 'codex' || platformArg === 'claude-code'
+                        ? { preferred_platform: platformArg }
+                        : existing?.preferred_platform
+                            ? { preferred_platform: existing.preferred_platform }
+                            : {}),
+                },
+            });
+        }
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    finally {
+        prompts?.close();
+    }
+}
+void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/scripts/ax-pause-work.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { pauseTopicWork } from '../core/observability/state-handoff.js';
+function usage() {
+    process.stderr.write('Usage: ax-pause-work --topic DIR --summary "<text>" [--next-step "<text>"] [--command "<text>"]...\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+function readArgs(flag) {
+    const values = [];
+    process.argv.forEach((arg, index) => {
+        if (arg === flag && process.argv[index + 1]) {
+            values.push(process.argv[index + 1]);
+        }
+    });
+    return values;
+}
+const topicDir = readArg('--topic');
+const summary = readArg('--summary');
+if (!topicDir || !summary) {
+    usage();
+    process.exit(1);
+}
+const result = await pauseTopicWork({
+    topicDir,
+    summary,
+    nextStep: readArg('--next-step'),
+    commands: readArgs('--command'),
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-platform-manifest.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { getPlatformAdapter } from '../adapters/index.js';
+function usage() {
+    process.stderr.write('Usage: ax-platform-manifest --platform <codex|claude-code> [--root DIR]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const platform = readArg('--platform');
+const rootDir = readArg('--root') || process.cwd();
+if (platform !== 'codex' && platform !== 'claude-code') {
+    usage();
+    process.exit(1);
+}
+const adapter = getPlatformAdapter(platform);
+process.stdout.write(`${JSON.stringify(adapter.getManifest(rootDir), null, 2)}\n`);

package/dist/scripts/ax-promote-thread.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { promoteThreadToTopic } from '../core/memory/thread-promotion.js';
+function usage() {
+    process.stderr.write('Usage: ax-promote-thread --root DIR --name NAME --request "<text>"\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const name = readArg('--name');
+const request = readArg('--request');
+if (!name || !request) {
+    usage();
+    process.exit(1);
+}
+const result = await promoteThreadToTopic({ rootDir, name, request });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-react-feedback.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { applyFeedbackReaction } from '../core/planning/feedback-reactions.js';
+function usage() {
+    process.stderr.write('Usage: ax-react-feedback --topic DIR --kind <review-changes-requested|ci-failed> --summary "<text>"\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const topicDir = readArg('--topic');
+const kind = readArg('--kind');
+const summary = readArg('--summary');
+if (!topicDir || !kind || !summary) {
+    usage();
+    process.exit(1);
+}
+if (kind !== 'review-changes-requested' && kind !== 'ci-failed') {
+    usage();
+    process.exit(1);
+}
+const result = await applyFeedbackReaction({
+    topicDir,
+    kind,
+    summary,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-recall-topics.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { searchPastTopics } from '../core/memory/topic-recall.js';
+function usage() {
+    process.stderr.write('Usage: ax-recall-topics --query "<text>" [--root DIR] [--limit N]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const query = readArg('--query');
+const rootDir = readArg('--root') || process.cwd();
+const limit = Number.parseInt(readArg('--limit') || '5', 10);
+if (!query) {
+    usage();
+    process.exit(1);
+}
+const result = await searchPastTopics({ rootDir, query, limit });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-recall.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { searchDecisionMemory } from '../core/memory/decision-register.js';
+import { searchPastTopics } from '../core/memory/topic-recall.js';
+import { buildContextBundle } from '../core/context/context-bundle.js';
+function usage() {
+    process.stderr.write('Usage: ax-recall --root DIR --scope <topic|decision|repo> --query "<text>" [--limit N]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const scope = readArg('--scope');
+const query = readArg('--query');
+const limit = Number(readArg('--limit') || '5');
+if (!scope || !query || !['topic', 'decision', 'repo'].includes(scope)) {
+    usage();
+    process.exit(1);
+}
+const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : 5;
+let result;
+if (scope === 'topic') {
+    result = await searchPastTopics({
+        rootDir,
+        query,
+        limit: normalizedLimit,
+    });
+}
+else if (scope === 'decision') {
+    result = await searchDecisionMemory({
+        rootDir,
+        query,
+        limit: normalizedLimit,
+    });
+}
+else {
+    const bundle = await buildContextBundle({
+        rootDir,
+        query,
+        maxChars: 3000,
+    });
+    result = {
+        base_context: bundle.sections.find((section) => section.kind === 'base_context')?.items ?? [],
+        topics: await searchPastTopics({
+            rootDir,
+            query,
+            limit: normalizedLimit,
+        }),
+        decisions: await searchDecisionMemory({
+            rootDir,
+            query,
+            limit: normalizedLimit,
+        }),
+    };
+}
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-refresh-state.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { writeRootStateSummary } from '../core/observability/state-handoff.js';
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const limit = Number(readArg('--limit') || '10');
+const result = await writeRootStateSummary({
+    rootDir,
+    limit: Number.isFinite(limit) && limit > 0 ? limit : 10,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-resolve-context.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { resolveContextFromIndex } from '../core/context/index-resolver.js';
+import { getGlobalContextHome } from '../core/settings/global-context-home.js';
+function usage() {
+    process.stderr.write('Usage: ax-resolve-context [--index PATH] --query "<text>" [--root DIR] [--max N]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const defaultIndexPath = (() => {
+    const home = getGlobalContextHome();
+    return readArg('--index') || home.indexPath;
+})();
+const localFallbackIndexPath = `${rootDir}/docs/base-context/index.md`;
+const indexPath = existsSync(defaultIndexPath) ? defaultIndexPath : localFallbackIndexPath;
+const query = readArg('--query');
+const maxMatches = Number.parseInt(readArg('--max') || '5', 10);
+if (!query) {
+    usage();
+    process.exit(1);
+}
+const result = await resolveContextFromIndex({
+    rootDir,
+    indexPath,
+    indexRootDir: indexPath === getGlobalContextHome().indexPath ? getGlobalContextHome().root : rootDir,
+    query,
+    maxMatches: Number.isFinite(maxMatches) && maxMatches > 0 ? maxMatches : 5,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-review.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { aggregateReviewVerdicts, writeAggregateReviewArtifacts, } from '../core/review/aggregate-reviews.js';
+import { runReviewLanes } from '../core/review/run-lanes.js';
+function usage() {
+    process.stderr.write('Usage: ax-review --topic DIR [--run]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const topicDir = readArg('--topic');
+const shouldRun = process.argv.includes('--run');
+if (!topicDir) {
+    usage();
+    process.exit(1);
+}
+if (shouldRun) {
+    await runReviewLanes({ topicDir });
+}
+const result = await aggregateReviewVerdicts({ topicDir });
+await writeAggregateReviewArtifacts(topicDir, result);
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);