@orqint/cli 0.1.0

package/dist/orqint/engine/context.d.ts

@@ -0,0 +1,4 @@
+import type { OrqintMemory } from "../types/memory";
+/** FR-007: minimal slices for Cursor handoffs (no full memory by default). */
+export declare function sliceForThink(memory: OrqintMemory, userIntent: string): Record<string, unknown>;
+export declare function sliceForPlan(memory: OrqintMemory): Record<string, unknown>;

package/dist/orqint/engine/context.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceForThink = sliceForThink;
+exports.sliceForPlan = sliceForPlan;
+/** FR-007: minimal slices for Cursor handoffs (no full memory by default). */
+function sliceForThink(memory, userIntent) {
+    return {
+        user_intent: userIntent,
+        project: memory.project,
+        goals: memory.goals,
+        open_questions: memory.open_questions,
+        confidence: memory.confidence,
+        unknowns: memory.unknowns,
+        requires_input: memory.requires_input,
+        override: memory.override,
+        rules: memory.rules,
+        decisions: memory.decisions,
+        tech_stack: memory.tech_stack,
+    };
+}
+function sliceForPlan(memory) {
+    return {
+        project: memory.project,
+        goals: memory.goals,
+        features: memory.features,
+        pages: memory.pages,
+        flows: memory.flows,
+        states: memory.states,
+        edge_cases: memory.edge_cases,
+        override: memory.override,
+        rules: memory.rules,
+        decisions: memory.decisions,
+        tech_stack: memory.tech_stack,
+        design_system: memory.design_system,
+        confidence: memory.confidence,
+        open_questions: memory.open_questions,
+    };
+}

package/dist/orqint/engine/handoff.d.ts

@@ -0,0 +1,82 @@
+export declare const THINK_RESPONSE_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["confidence", "open_questions"];
+    readonly properties: {
+        readonly project: {
+            readonly type: "object";
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly type: {
+                    readonly type: "string";
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly project_type: {
+            readonly type: "string";
+            readonly description: "If set, merged into project.type when project.type empty or overridden by analysis";
+        };
+        readonly goals: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly open_questions: {
+            readonly type: "array";
+            readonly maxItems: 5;
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Max 5 high-value questions (PRD §3.1)";
+        };
+        readonly confidence: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly unknowns: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly requires_input: {
+            readonly type: "boolean";
+        };
+        readonly tech_stack: {
+            readonly type: "object";
+        };
+    };
+};
+export declare const PLAN_RESPONSE_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["features", "flows", "pages", "states"];
+    readonly properties: {
+        readonly features: {
+            readonly type: "array";
+        };
+        readonly flows: {
+            readonly type: "array";
+        };
+        readonly pages: {
+            readonly type: "array";
+        };
+        readonly states: {
+            readonly type: "array";
+        };
+        readonly edge_cases: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare function loadPromptTemplate(cwd: string, name: "intent.txt" | "plan.txt"): Promise<string>;
+export declare function writeThinkHandoff(cwd: string, userIntent: string, slicedMemory: Record<string, unknown>): Promise<string>;
+export declare function writePlanHandoff(cwd: string, slicedMemory: Record<string, unknown>): Promise<string>;

package/dist/orqint/engine/handoff.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAN_RESPONSE_SCHEMA = exports.THINK_RESPONSE_SCHEMA = void 0;
+exports.loadPromptTemplate = loadPromptTemplate;
+exports.writeThinkHandoff = writeThinkHandoff;
+exports.writePlanHandoff = writePlanHandoff;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+exports.THINK_RESPONSE_SCHEMA = {
+    type: "object",
+    required: ["confidence", "open_questions"],
+    properties: {
+        project: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                type: { type: "string" },
+                description: { type: "string" },
+            },
+        },
+        project_type: {
+            type: "string",
+            description: "If set, merged into project.type when project.type empty or overridden by analysis",
+        },
+        goals: { type: "array", items: { type: "string" } },
+        open_questions: {
+            type: "array",
+            maxItems: 5,
+            items: { type: "string" },
+            description: "Max 5 high-value questions (PRD §3.1)",
+        },
+        confidence: { type: "number", minimum: 0, maximum: 1 },
+        unknowns: { type: "array", items: { type: "string" } },
+        requires_input: { type: "boolean" },
+        tech_stack: { type: "object" },
+    },
+};
+exports.PLAN_RESPONSE_SCHEMA = {
+    type: "object",
+    required: ["features", "flows", "pages", "states"],
+    properties: {
+        features: { type: "array" },
+        flows: { type: "array" },
+        pages: { type: "array" },
+        states: { type: "array" },
+        edge_cases: { type: "array", items: { type: "string" } },
+    },
+};
+async function loadPromptTemplate(cwd, name) {
+    const p = path.join((0, paths_1.promptsDir)(cwd), name);
+    const exists = await fs.pathExists(p);
+    if (!exists) {
+        throw new Error(`Missing prompt template: ${p}`);
+    }
+    return fs.readFile(p, "utf8");
+}
+function substitute(template, vars) {
+    let out = template;
+    for (const [k, v] of Object.entries(vars)) {
+        out = out.split(`{{${k}}}`).join(v);
+    }
+    return out;
+}
+async function writeThinkHandoff(cwd, userIntent, slicedMemory) {
+    await fs.ensureDir((0, paths_1.handoffDir)(cwd));
+    const intentTpl = await loadPromptTemplate(cwd, "intent.txt");
+    const body = substitute(intentTpl, {
+        input: userIntent,
+        sliced_memory: JSON.stringify(slicedMemory, null, 2),
+        response_schema: JSON.stringify(exports.THINK_RESPONSE_SCHEMA, null, 2),
+    });
+    const full = `# Orqint think handoff
+
+Save your **final answer** as JSON only to \`orqint/.handoff/think.response.json\`, then run:
+
+\`\`\`
+orqint think apply --file orqint/.handoff/think.response.json
+\`\`\`
+
+---
+
+${body}
+`;
+    const outPath = path.join((0, paths_1.handoffDir)(cwd), "think.md");
+    await fs.writeFile(outPath, full, "utf8");
+    return outPath;
+}
+async function writePlanHandoff(cwd, slicedMemory) {
+    await fs.ensureDir((0, paths_1.handoffDir)(cwd));
+    const planTpl = await loadPromptTemplate(cwd, "plan.txt");
+    const body = substitute(planTpl, {
+        sliced_memory: JSON.stringify(slicedMemory, null, 2),
+        response_schema: JSON.stringify(exports.PLAN_RESPONSE_SCHEMA, null, 2),
+    });
+    const full = `# Orqint plan handoff
+
+Save your **final answer** as JSON only to \`orqint/.handoff/plan.response.json\`, then run:
+
+\`\`\`
+orqint plan apply --file orqint/.handoff/plan.response.json
+\`\`\`
+
+---
+
+${body}
+`;
+    const outPath = path.join((0, paths_1.handoffDir)(cwd), "plan.md");
+    await fs.writeFile(outPath, full, "utf8");
+    return outPath;
+}

package/dist/orqint/engine/paths.d.ts

@@ -0,0 +1,6 @@
+export declare function orqintRoot(cwd: string): string;
+export declare function memoryJsonPath(cwd: string): string;
+export declare function handoffDir(cwd: string): string;
+export declare function promptsDir(cwd: string): string;
+export declare function orqintSpecDir(cwd: string): string;
+export declare function orqintArchiveDir(cwd: string): string;

package/dist/orqint/engine/paths.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orqintRoot = orqintRoot;
+exports.memoryJsonPath = memoryJsonPath;
+exports.handoffDir = handoffDir;
+exports.promptsDir = promptsDir;
+exports.orqintSpecDir = orqintSpecDir;
+exports.orqintArchiveDir = orqintArchiveDir;
+const path = __importStar(require("path"));
+function orqintRoot(cwd) {
+    return path.join(cwd, "orqint");
+}
+function memoryJsonPath(cwd) {
+    return path.join(orqintRoot(cwd), "core", "memory.json");
+}
+function handoffDir(cwd) {
+    return path.join(orqintRoot(cwd), ".handoff");
+}
+function promptsDir(cwd) {
+    return path.join(orqintRoot(cwd), "prompts");
+}
+function orqintSpecDir(cwd) {
+    return path.join(cwd, "orqint-spec");
+}
+function orqintArchiveDir(cwd) {
+    return path.join(cwd, "orqint-archive");
+}

package/dist/orqint/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/orqint/index.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const init_1 = require("./commands/init");
+const think_1 = require("./commands/think");
+const plan_1 = require("./commands/plan");
+const package_meta_1 = require("./package-meta");
+const update_1 = require("./commands/update");
+function printHelp() {
+    const { name, version } = (0, package_meta_1.readPackageMeta)();
+    console.log(`${name} ${version} — Phase 1 (Cursor-native)
+
+No model API keys in this tool: use Cursor on the generated handoff files, then apply JSON.
+
+Commands:
+  orqint version | --version | -V
+  orqint update [--install] [<args>...]   check npm; --install runs npx ${name}@latest <args>
+  orqint init [--brownfield] [--migrate-legacy] [--force]
+  orqint think prepare "<intent>" [--override key=value ...]
+  orqint think apply --file <path>
+  orqint plan prepare [--force]
+  orqint plan apply --file <path> [--force]
+
+Examples:
+  orqint init --brownfield
+  orqint think prepare "Build a task dashboard" --override mobile_first=true
+  orqint think apply --file orqint/.handoff/think.response.json
+  orqint plan prepare
+  orqint plan apply --file orqint/.handoff/plan.response.json
+`);
+}
+function parseOverrideArgs(args) {
+    const overrides = {};
+    const rest = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--override" && args[i + 1]) {
+            const raw = args[++i];
+            const eq = raw.indexOf("=");
+            if (eq === -1) {
+                throw new Error(`--override expects key=value, got: ${raw}`);
+            }
+            const key = raw.slice(0, eq).trim();
+            const val = raw.slice(eq + 1).trim();
+            const low = val.toLowerCase();
+            overrides[key] =
+                low === "true" ? true : low === "false" ? false : val;
+        }
+        else {
+            rest.push(args[i]);
+        }
+    }
+    return { rest, overrides };
+}
+function takeFlag(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return false;
+    }
+    args.splice(i, 1);
+    return true;
+}
+function takeFileArg(args) {
+    const i = args.indexOf("--file");
+    if (i === -1 || !args[i + 1]) {
+        return undefined;
+    }
+    const p = args[i + 1];
+    args.splice(i, 2);
+    return p;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const cwd = process.cwd();
+    if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help") {
+        printHelp();
+        process.exit(0);
+    }
+    if (argv[0] === "--version" ||
+        argv[0] === "-V" ||
+        argv[0] === "version") {
+        const m = (0, package_meta_1.readPackageMeta)();
+        console.log(`${m.version}`);
+        process.exit(0);
+    }
+    const cmd = argv[0];
+    try {
+        if (cmd === "update") {
+            const rest = argv.slice(1);
+            const install = takeFlag(rest, "--install");
+            (0, update_1.runUpdate)((0, package_meta_1.readPackageMeta)(), install, rest);
+            return;
+        }
+        if (cmd === "init") {
+            const args = argv.slice(1);
+            await (0, init_1.runInit)(cwd, {
+                force: takeFlag(args, "--force"),
+                brownfield: takeFlag(args, "--brownfield"),
+                migrateLegacy: takeFlag(args, "--migrate-legacy"),
+            });
+            console.error("Orqint initialized.");
+            process.exit(0);
+        }
+        if (cmd === "think" && argv[1] === "prepare") {
+            const { rest, overrides } = parseOverrideArgs(argv.slice(2));
+            const intent = rest.join(" ").trim();
+            if (!intent) {
+                throw new Error('Missing intent text after "think prepare"');
+            }
+            const { handoffPath } = await (0, think_1.thinkPrepare)(cwd, intent, overrides);
+            console.error(`Handoff written: ${handoffPath}`);
+            console.log(handoffPath);
+            process.exit(0);
+        }
+        if (cmd === "think" && argv[1] === "apply") {
+            const args = argv.slice(2);
+            const file = takeFileArg(args);
+            if (!file) {
+                throw new Error("think apply requires --file <path>");
+            }
+            const abs = path.isAbsolute(file) ? file : path.join(cwd, file);
+            const { exitCode, messages } = await (0, think_1.thinkApply)(cwd, abs);
+            for (const m of messages) {
+                console.error(m);
+            }
+            process.exit(exitCode);
+        }
+        if (cmd === "plan" && argv[1] === "prepare") {
+            const args = argv.slice(2);
+            const force = takeFlag(args, "--force");
+            const { handoffPath } = force
+                ? await (0, plan_1.planPrepareAllowLowConfidence)(cwd)
+                : await (0, plan_1.planPrepare)(cwd);
+            console.error(`Handoff written: ${handoffPath}`);
+            console.log(handoffPath);
+            process.exit(0);
+        }
+        if (cmd === "plan" && argv[1] === "apply") {
+            const args = argv.slice(2);
+            const force = takeFlag(args, "--force");
+            const file = takeFileArg(args);
+            if (!file) {
+                throw new Error("plan apply requires --file <path>");
+            }
+            const abs = path.isAbsolute(file) ? file : path.join(cwd, file);
+            await (0, plan_1.planApply)(cwd, abs, force);
+            console.error("Plan merged into memory and orqint-spec/ updated.");
+            process.exit(0);
+        }
+        printHelp();
+        process.exit(1);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(msg);
+        process.exit(1);
+    }
+}
+void main();

package/dist/orqint/package-meta.d.ts

@@ -0,0 +1,8 @@
+export type PackageMeta = {
+    name: string;
+    version: string;
+};
+/**
+ * Resolves the published package root (contains package.json next to dist/).
+ */
+export declare function readPackageMeta(): PackageMeta;

package/dist/orqint/package-meta.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageMeta = readPackageMeta;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Resolves the published package root (contains package.json next to dist/).
+ */
+function readPackageMeta() {
+    const pkgPath = path.join(__dirname, "..", "..", "package.json");
+    try {
+        const raw = fs.readFileSync(pkgPath, "utf8");
+        const pkg = JSON.parse(raw);
+        return {
+            name: typeof pkg.name === "string" ? pkg.name : "@orqint/cli",
+            version: typeof pkg.version === "string" ? pkg.version : "0.0.0",
+        };
+    }
+    catch {
+        return { name: "@orqint/cli", version: "0.0.0-dev" };
+    }
+}

package/dist/orqint/prompts/intent.txt

@@ -0,0 +1,29 @@
+You are an expert product architect. The user runs you inside **Cursor** as the Orqint intent step.
+
+## Human overrides (absolute — CGR-012)
+
+These constraints from memory override your defaults. If `override` is non-empty in the sliced memory JSON, obey every key (e.g. no_supabase, mobile_first).
+
+## Sliced memory (context)
+
+```json
+{{sliced_memory}}
+```
+
+## User intent
+
+{{input}}
+
+## Your task
+
+1. Refine understanding of the product: `project` (name, type, optional description), `goals`.
+2. Propose `tech_stack` patches only when justified by the intent and existing memory; respect overrides.
+3. Set `confidence` between 0 and 1.
+4. List at most **five** focused `open_questions` when confidence is below 0.8 or when critical forks remain; otherwise use an empty array or fewer.
+5. Set `unknowns` (strings) and `requires_input` when the user must answer before planning.
+
+## Response schema (return JSON only — no markdown)
+
+Match this structure (types as described):
+
+{{response_schema}}

package/dist/orqint/prompts/plan.txt

@@ -0,0 +1,27 @@
+You are an expert product and UX architect. The user runs you inside **Cursor** as the Orqint **plan** step.
+
+## Human overrides (absolute — CGR-012)
+
+Obey every entry in `override` from the sliced memory below.
+
+## Sliced memory
+
+```json
+{{sliced_memory}}
+```
+
+## Your task
+
+From the memory slice, produce or refresh:
+
+- `features` — discrete, verifiable product capabilities
+- `flows` — user or system flows
+- `pages` — page-level or screen-level structure where applicable
+- `states` — notable UI/state-machine notes
+- `edge_cases` — important edge cases (array of strings)
+
+Keep outputs structured (objects/strings in arrays) so the CLI can merge them into `memory.json`.
+
+## Response schema (return JSON only — no markdown)
+
+{{response_schema}}